Skip to content

Replay Scheduler

Status: MVP complete (M1 crate, daemon host adapter, Agora replay adapter, and operator surface)

Based on: doc/project/60-solutions/008-agora/008-agora.md, doc/project/60-solutions/008-agora/008-agora-dir-simplify-impl.md, doc/project/60-solutions/016-bounded-local-server-runtime/016-bounded-local-server-runtime.md, node/storage-projector, node/agora-projections, and the Node replay-scheduler / daemon host-adapter implementation.

Date: 2026-05-04

Last synchronized: 2026-10-11 (due-job admission ordering)

Executive Summary

The Replay Scheduler is a shared host-owned runtime primitive for bounded periodic jobs. Its first production consumer is Agora projection replay: comments, resource opinions, public gossip, Seed Directory projections, and offer publication projections can be kept fresh from local relay stores without an external trigger.

The scheduler decides when a registered job may run. It does not decide whether a component is allowed to perform a domain action, does not interpret Agora records, and does not allow one middleware component to force work inside another component. Domain authorization remains behind a host-owned authority gate, and each job stays owned by an explicit component/runtime API.

The implementation should live as a reusable Node crate, tentatively node/replay-scheduler / orbiplex-node-replay-scheduler, with the daemon/host providing the standard runtime adapter.

As of 2026-05-18, the M1 runtime slice exists in Node as node/replay-scheduler plus a daemon host adapter. It implements the generic crate, durable SQLite launch ledger, bounded launch gates, jitter/backoff, same-gate run-once, cooperative shutdown, job-source normalization helpers, and contract tests. The daemon extracts jobs from node config and effective signed middleware package fragments, registers agora.projection.replay as the first production action, exposes host scheduler status/control API, and renders /admin/scheduler with HTMX-refreshing job controls and per-job execution history.

Context and Problem Statement

Agora M2 moves several public and federated domains toward replay-fed projections. Without a common scheduler, each component tends to grow its own periodic loop, retry policy, shutdown behavior, status surface, and partial backoff logic. That creates hidden coupling and makes it harder to reason about overload, missed launches, and cross-component authority boundaries.

The scheduler is needed to provide one small, auditable primitive for:

  • periodic projection replay per topic/domain,
  • bounded concurrency and bounded retry,
  • deterministic jitter to avoid synchronized launch spikes,
  • durable launch state for restart safety,
  • operator-visible status,
  • one consistent authority gate for automatic and manual run-once launches.

This document is solution-level. It defines responsibilities and invariants. Concrete module layout, exact Rust type names, and endpoint implementation details belong in the Node implementation repository.

Proposed Model / Decision

P091-007b is a consumer of this existing scheduler for bounded configuration source reconciliation, adopted on 2026-10-18. Its default one-second interval is file-configured; the configuration owner supplies source selection, admission and lifecycle semantics. Missed/overloaded launches expose stale inspection; inspection never runs the job. This delivery adds no private timer/watcher. The consumer distinguishes a persisted observation from an attempted lifecycle effect: tick budget exhaustion retains still-current unattempted transitions, but does not authorize replay of uncertain effects. Source/application semantics and this distinction belong to the configuration consumer, not the scheduler. The 2026-10-18 closeout exercises actual one-slot saturation with a bounded test pressure job, the production S020 consumer and real Messaging: stale observation while the slot is occupied, then normal disable after release, without treating observation as stop acknowledgement or re-enabling a protected false. This is not an arbitrary-load fairness/SLA or fleet-pressure campaign.

The same consumer owns the distinction between observed equality and application history: remove/start/external-false between equal false observations must not lose the first disable. This is a consumer request-selection correction, not a scheduler deadline or fairness change; a reserved uncertain effect is still not automatically retried. See the Node causal follow-up for the controlled counterexample and exact qualification boundary.

The core contract is deliberately small:

Scheduler decides when a launch may be attempted.
Job decides what execution means.
Authority/policy gate decides whether the job may run now.
Projection/runtime decides how records are processed.

Stratification

replay-scheduler
  time source
  jitter/backoff policy
  launch ledger
  bounded worker pool
  ScheduledJob trait
  status snapshots

host/daemon adapter
  merges local job sources
  injects owner_component_id
  binds specs to runtime-owned APIs
  provides ScheduledJobAuthority

agora-service / other components
  own domain job specs
  own domain replay code
  expose domain-specific operator meaning

agora-projections / domain read models
  validate and apply records
  own cursors and projection semantics

The scheduler is generic. Agora is the first consumer, not the owner of the primitive.

Responsibilities

The scheduler must implement:

  • registration of already-normalized job specs,
  • next-due calculation,
  • stable per-job/per-window jitter,
  • full jitter for transient retry where appropriate,
  • capped backoff after failures,
  • global and per-job concurrency limits,
  • overlap policy,
  • missed-launch policy,
  • durable launch ledger,
  • cooperative shutdown and bounded drain,
  • in-memory status snapshots backed by durable launch history,
  • operator-visible error classes.

Registration is transactional at the scheduler boundary: an already registered job_id is rejected before the durable job row is inserted or replaced. A conflicting runtime registration therefore cannot mutate the persisted schedule. Execution deadlines remain cooperative for in-process ScheduledJob implementations; preemptive termination belongs only to process-backed runners owned by a supervisor, not to this generic scheduler primitive.

Periodic admission considers the oldest due window first, with job_id as a stable tie-breaker. Selecting a launch advances its next window; an already waiting eligible job therefore precedes a rapidly recurring job on subsequent ticks. Hash-map iteration order is not an admission policy. This preserves the global/per-job gates, overlap rules and independent authority checks; it does not promise progress while non-cooperative work occupies every launch slot. Node has deterministic selection tests for continuous recurrence and equal windows. This correction does not itself qualify a domain publication.

The scheduler must not implement:

  • Agora record validation,
  • semantic interpretation of record/kind or content/schema,
  • capability/passport/domain authorization,
  • signing or delegated signing,
  • direct cross-middleware calls without a host-owned capability boundary,
  • component configuration merge,
  • process restart or supervision,
  • trust, moderation, reputation, or Seed Directory policy.

Deferred Operation Continuations

Proposal 055 adds a bounded deferred-operation contract for calls that cannot produce a final value inside one normal request budget. This does not turn the scheduler into a domain workflow engine. The scheduler or a lighter poller may drive the wake-up timing, but the continuation itself is a host/runtime-owned data value.

The important boundary is:

deferred = runtime control outcome
deferred != ordinary domain payload

Downstream components should not receive deferred as normal input unless they explicitly declare a control-plane role that handles deferred operation state. The default runtime behavior is to stop the current branch, persist a continuation context, poll or wait until the deferred operation completes, then resume from the recorded point with the final value.

This prevents every downstream component from needing domain knowledge about \"try again later\" semantics. A component after the deferred edge sees either a normal completed value or a terminal failure/timeout.

Continuation Context as Data

Orbiplex should not try to capture a language/runtime stack. A continuation is a serializable value:

ContinuationContext = data required to resume one flow from one explicit point

The context should contain only durable, replayable data:

  • schema, for example orbiplex-continuation.v1,
  • continuation_id,
  • owning workflow/run ids where present,
  • owning component/module id,
  • deferred operation_id,
  • resume kind and resume point,
  • caller/capability snapshot,
  • original input or current flow context as JSON,
  • optional envelope or workflow envelope snapshot,
  • trace/correlation ids,
  • idempotency key,
  • deadline and retry policy snapshot,
  • attempt counters and last diagnostic.

The context must not contain:

  • Rust stack frames,
  • closures/functions,
  • thread handles,
  • sockets,
  • locks,
  • open files,
  • live child-process handles,
  • borrowed references.

For JSON-e Flow, the natural continuation is:

template_id
step_index / step_id
current_context_json
output_binding
deferred operation_id
trace id
deadline
idempotency key

On resume, the host/runtime polls operation_id, receives a completed result, binds it to current_context_json[output_binding], and continues with step_index + 1.

Execution Strategies

The preferred strategy is continuation-resume from the first implementation:

component step calls deferred-capable capability
  -> receives deferred(operation_id)
  -> runtime persists ContinuationContext
  -> runtime stops the branch
  -> scheduler/poller checks status later
  -> completed(result)
  -> runtime resumes from the stored resume point
  -> downstream receives completed value only

A simpler abort-and-reschedule-step strategy is acceptable only as a fallback for idempotent steps, but it should not be the target architecture. It retries a larger part of the flow and therefore makes side-effect idempotency more fragile.

The anti-pattern is passing deferred downstream as domain data. That complects control flow with domain payloads and forces every component to learn the same retry semantics.

Scheduler Boundary

The scheduler may store wake-up state and launch the poll/resume action, but it does not interpret the continuation payload beyond generic owner/action fields. The owning runtime remains responsible for validating the continuation schema, checking authority, polling the deferred operation, and resuming the flow.

In short:

scheduler = when to wake
deferred-operation runtime = how to poll and decide terminal state
owning interpreter = how to resume the domain flow

Job Ownership and Authority Boundary

Every runtime job must carry explicit ownership data:

  • job_id,
  • owner_component_id,
  • owner_runtime_api,
  • domain,
  • optional topic_key,
  • action.

These fields are not UI metadata. They are the inputs to the host-owned ScheduledJobAuthority. The same authority path must be used for periodic launches and operator-triggered run-once launches.

Example normalized Agora replay job:

{
  "job_id": "agora.comments.replay.default",
  "owner_component_id": "agora-service",
  "owner_runtime_api": "component-local",
  "action": "agora.projection.replay",
  "domain": "comments",
  "topic_key": "ai.orbiplex.comments/example",
  "interval_ms": 15000,
  "enabled": true
}

A component may register or configure jobs for its own runtime API. A component must not register a job that invokes another component's private action unless the host exposes an explicit delegated capability contract for that action.

Planned Local Device Discovery Repeat Policy

P045 local device discovery continuation owns the planned P045-DISC-001–007 work. No discovery job is registered by default: an admitted provider, package factory configuration, previous scan, empty result, or restart must not silently enable periodic or autonomously retried scanning. Repeated scans require an explicit separate repeat policy admitted by the Sensorium domain owner and the host authority gate.

The owning domain and host enforce current caller/action/profile authority, per-caller frequency limits, a shared transport budget that survives restart, controller claims, and the V1 refusal to scan during acquisition on that controller. They apply the same gate to manual and any explicitly authorized scheduled launch. These are discovery semantics, not new responsibilities of the generic scheduler core. Its retry or catch-up policy cannot grant a fresh scan or bypass the domain's refusal.

Polling an existing S029 discovery operation reads its current private status; it does not start another scan, renew the scan window, or replenish its budget. The planned P055/S029 status-v2 integration carries bounded replacement candidate snapshots through the existing status/poll/cancel path. Candidate lists are not scheduler job state, durable launch outcomes, or resumable continuation payloads; restart invalidates them and never resumes discovery automatically. The domain owner and existing supervisor own confirmed session cleanup, rather than the scheduler terminating a controller or implementing a second process lifecycle.

These requirements are planned, under the single P045 tracker, and do not change the scheduler's implemented M1 status. P048 owns effect-envelope constraints; P045 owns the discovery operation and authorization rules.

Local Job Sources and Merge Rules

Job sources are local and host-owned. Valid sources include:

  • global host configuration,
  • component configuration,
  • built-in or external middleware package factory configuration that has become effective after Local Readiness Gate acceptance,
  • runtime-owned registration API for the calling component's own jobs,
  • explicit operator action such as enabling replay for a topic.

Invalid sources include:

  • an Agora record that directly creates a local job,
  • a remote peer that forces a local resynchronization,
  • middleware A registering a job to execute middleware B without a host policy gate.

The host/daemon adapter, not the scheduler crate, normalizes job sources into final ScheduledJobSpec values. Merge rules:

  1. Global host jobs receive an explicit host-owned owner_component_id, such as daemon.
  2. Component config jobs receive the owner id of that component.
  3. Middleware package factory jobs receive the owner id of the package/component that contributes the job.
  4. Runtime registration may only register the caller's own owner_component_id, unless an explicit delegated capability contract exists.
  5. job_id conflicts are configuration errors unless an explicit override mechanism is used under the same owner. The accepted override shape is: same owner_component_id, same job_id, and explicit override_existing: true. The daemon parser also accepts override: true as a compatibility alias.

owner_runtime_api is a string at the configuration/wire boundary. The host adapter normalizes known values and rejects unknown values before the scheduler sees the job.

Middleware package job specs are read only from effective package configuration. In other words, package artifact signing and operator acceptance are handled before job extraction:

middleware package artifact signed/accepted
  -> package config becomes effective
  -> host adapter extracts package-owned job specs
  -> scheduler receives normalized jobs

The scheduler does not validate package signatures.

The first implemented package fragment kind is:

{
  "kind": "daemon.scheduler_jobs",
  "path": "config/scheduler-jobs.json"
}

The fragment body is a map keyed by job_id. Each value is a daemon scheduler job config. Daemon-facing job ids are also used in host HTTP paths, so they must be a single path segment using only ASCII letters, digits, ., _, -, and ~. For Agora replay jobs, action is agora.projection.replay and the action-specific payload is carried under agora_projection_replay. The host adapter normalizes that shape into a ScheduledJobSpec; the generic scheduler never reads package manifests or Agora semantics directly.

Example:

{
  "agora.comments.example": {
    "owner_component_id": "agora-service",
    "owner_runtime_api": "component-local",
    "action": "agora.projection.replay",
    "domain": "agora.comments",
    "topic_key": "ai.orbiplex.comments/example",
    "interval_ms": 15000,
    "agora_projection_replay": {
      "executor_id": "agora-service",
      "record_kind": "comment",
      "content_schema": "plain-comment.v1",
      "limit": 100
    }
  }
}

Launch Ledger

The runtime scheduler requires a durable launch ledger from the first implementation. An in-memory ledger is acceptable only as a test fixture. If the durable ledger cannot be opened, runtime startup must fail closed or the scheduler must be disabled with a clear operator-visible error. Silent fallback to volatile runtime state is not allowed.

The launch ledger is separate from domain cursors. It records scheduler decisions, not domain projection state.

Minimum logical tables:

CREATE TABLE IF NOT EXISTS scheduled_jobs (
    job_id TEXT PRIMARY KEY,
    owner_component_id TEXT NOT NULL,
    owner_runtime_api TEXT NOT NULL,
    domain TEXT NOT NULL,
    topic_key TEXT,
    action TEXT NOT NULL,
    enabled INTEGER NOT NULL,
    interval_ms INTEGER NOT NULL,
    next_due_at TEXT,
    last_started_at TEXT,
    last_finished_at TEXT,
    last_status TEXT,
    consecutive_failures INTEGER NOT NULL DEFAULT 0,
    updated_at TEXT NOT NULL
);

CREATE TABLE IF NOT EXISTS scheduled_launches (
    launch_id TEXT PRIMARY KEY,
    job_id TEXT NOT NULL,
    scheduled_for TEXT NOT NULL,
    started_at TEXT NOT NULL,
    finished_at TEXT,
    status TEXT NOT NULL,
    attempt INTEGER NOT NULL DEFAULT 1,
    error_class TEXT,
    error_message TEXT,
    outcome_json TEXT,
    UNIQUE(job_id, scheduled_for)
);

launch_id should be deterministic, for example from canonical JSON over job_id, scheduled_for, and attempt. This makes restart recovery and duplicate launch detection auditable.

Scheduling Semantics

Default policies:

overlap = SkipIfRunning
catch_up = RunOnceIfMissed

Rationale: replay/projection jobs should be idempotent, but the dependencies they exercise are not necessarily cheap. After downtime, the system should catch up with one bounded run rather than creating a replay storm.

A run should be short and bounded. For Agora projection replay:

one run = one bounded replay page or one bounded replay loop with a deadline

The first daemon adapter uses the page form: agora.projection.replay requires a positive agora_projection_replay.limit, and the Agora projection store advances its own durable cursor after each page. The scheduler job does not loop over all remaining pages in one launch; the next scheduler tick advances the next bounded page.

Not:

one run = replay everything without limit

Stable jitter should be deterministic per job_id and scheduled window so restarts remain diagnosable while avoiding synchronized launches. Transient retry can use full jitter with capped backoff.

Failure Modes and Mitigations

Failure class Meaning Mitigation
transient temporary transport/store failure capped backoff + jitter
overloaded dependency rejects or signals overload longer cooldown; no tight loop
authorization-denied authority/capability gate denied launch disable or slow retry; operator-visible
invalid-config local job spec/config is invalid fail closed or disable job; operator-visible
non-retryable domain error where retry is not useful mark failed; operator-visible
deadline-exceeded job exceeded execution budget backoff; domain may reduce page size
ambiguous started launch restart found started without finished_at fail closed for that launch window; avoid double launch

The scheduler must never busy-spin on repeated failure.

Shutdown Contract

The scheduler must support:

  • a stop token visible to running jobs,
  • no new launches after stop begins,
  • graceful drain up to shutdown_grace,
  • final status persistence for interrupted jobs,
  • cooperative cancellation between replay pages or other bounded work units.

The scheduler does not preemptively kill a job. Jobs must observe the stop token at safe boundaries.

Agora Projection Replay as First Consumer

Agora service should register projection replay jobs for public/federated read models, for example:

  • comments,
  • resource opinions,
  • public gossip,
  • Seed Directory accepted-record projections,
  • offer publication snapshot projections.

Each Agora-owned job invokes the Agora projection layer, such as ProjectionStore::replay_topic_from_relay(...), and returns a generic job outcome:

{
  "schema": "scheduled-job-outcome.v1",
  "records_seen": 100,
  "records_applied": 97,
  "records_skipped": 2,
  "records_rejected": 1,
  "cursor": "1234",
  "lag_hint": {
    "topic_key": "ai.orbiplex.comments/example",
    "last_sequence": 1234
  }
}

The scheduler sees this as data. Agora remains responsible for explaining what the numbers mean for a topic, schema, cursor, or read model.

Operator Visibility

The scheduler crate should expose pure data snapshots. If HTTP is exposed, it belongs to the host component or component-specific UI surface, not to the generic crate.

A host may expose:

GET /v1/scheduler
GET /v1/scheduler/jobs/{job-id}
POST /v1/scheduler/jobs/{job-id}/run-once
POST /v1/scheduler/jobs/{job-id}/pause
POST /v1/scheduler/jobs/{job-id}/resume

Component UIs should add domain meaning. For example, Agora UI should show topic, record kind, content schema, cursor, lag, applied/skipped/rejected counts, and the last domain error for Agora-owned replay jobs.

Implementation Phases

Phase 1 — Scheduler crate and clean runtime

  • Add node/replay-scheduler.
  • Define scheduler config, job spec, job trait, authority trait, outcomes, and error classes.
  • Implement durable SQLite launch ledger from the start.
  • Implement stable jitter, full jitter, capped backoff, bounded worker pool, and cooperative shutdown.
  • Add restart/double-launch tests.

Status: done. The implementation enforces bounded concurrent launches by global and per-job gates.

Phase 2 — Host adapter and job-source merge

  • Normalize global host jobs, component jobs, and middleware-package factory jobs from effective package configuration after Local Readiness Gate acceptance.
  • Inject owner_component_id, owner_runtime_api, and action.
  • Normalize owner_runtime_api as a string and reject unknown values.
  • Reject conflicting job_id values unless the override has the same owner_component_id, the same job_id, and explicit override_existing: true.
  • Block runtime registration for another component's owner id unless a delegated capability contract allows it.

Status: done. The daemon host adapter owns job-source extraction from node config and effective signed middleware package fragments, validates ownership, rejects unknown runtime APIs, rejects cross-owner overrides, and normalizes accepted specs before the scheduler sees them.

The 2026-10-20 consumer regression follow-up exercises the configuration reconciler with actual Messaging processes and explicit executable prerequisites, including slot pressure and remove -> explicit start -> external false. Cold SQLite initialization belongs to Messaging (S027): its schema/bootstrap now commit atomically before channel attach. Scheduler budgets, launch admission, current configuration authority and uncertain-effect fencing are unchanged. The retained software review is node:docs/audits/DAEMON-SENSORIUM-S020-REGRESSION-2026-10-20.md; passing a consumer regression does not qualify the whole P091/P095 UI/runtime matrix or explain a historical timeout whose internal startup snapshot was not retained.

Phase 3 — Agora adapter

  • Register Agora M2 projection jobs from Agora-owned configuration.
  • Route jobs to ProjectionStore::replay_topic_from_relay(...).
  • Add status to host scheduler status and/or Agora status surface.
  • Cover in-memory and SQLite relay/store paths in tests.

Status: done for M1. agora.projection.replay is the first production action; the daemon job adapter calls the Agora component's loopback operator replay endpoint, and Story-009 profiles register comments, thread-policy, opinions, and public-gossip replay jobs explicitly. Richer Agora-domain lag/cursor/detail panels are post-M1 UI work, not MVP closure criteria for the shared scheduler primitive.

Phase 4 — Operator UI

  • Host UI shows generic scheduler mechanics.
  • Agora UI surfaces Agora-owned jobs with domain-specific meaning.
  • run-once, pause, and resume remain gated by the same authority path as periodic launches.

Status: done for the generic host-owned surface. The daemon exposes status, job detail, pause/resume, and run-once routes; Node UI renders /admin/scheduler with HTMX-refreshed job state and per-job execution history. Component-specific Agora projection panels remain a post-M1 extension.

Trade-offs

Benefits:

  • one scheduler primitive instead of ad-hoc loops,
  • consistent overload/backoff/shutdown semantics,
  • restart-safe launch accounting,
  • clear authority boundary between timing and domain permission,
  • reusable primitive for non-Agora maintenance jobs.

Costs and constraints:

  • durable ledger adds implementation cost early,
  • host adapter must normalize job sources carefully,
  • strict ownership prevents some convenient shortcuts,
  • distributed leadership is explicitly deferred.

Deferred intentionally:

  • distributed scheduler leadership,
  • declarative DAG/dependency scheduling,
  • remote peers creating local jobs,
  • public protocol semantics for scheduler state.

Invariants

  • Scheduler does not run work without an explicit registered owner.
  • Scheduler does not accept runtime job specs missing owner/action fields.
  • Scheduler never lets one middleware force another middleware's private action without host-owned capability/policy approval.
  • Host adapter owns job-source merge and owner injection.
  • Every launch has a deterministic launch_id.
  • Runtime uses a durable launch ledger.
  • Default policy prevents overlap.
  • Default missed-launch policy runs at most one catch-up launch.
  • Retry has backoff, jitter, cap, and visible error class.
  • Shutdown is cooperative and bounded.
  • Replay jobs are idempotent and paged or deadline-bounded.
  • Operator can inspect due/running/failed/paused state and the reason for failure.

Open Questions

No protocol-level open questions remain for the M1 scheduler contract.

The M1 implementation has landed. Remaining review topics are ordinary hardening follow-ups rather than protocol blockers:

  1. The exact list of initially known owner_runtime_api string values.
  2. The exact audit payload for accepted same-owner overrides.
  3. The concrete host configuration path for global scheduler settings.

Post-M1 Follow-Ups

  1. Add richer Agora-domain projection lag/cursor/detail panels on top of the generic host scheduler job state.
  2. Promote additional host maintenance loops to the shared scheduler only after they have explicit ownership and authority boundaries.
  3. Keep scheduler documentation synchronized with Rust data shapes as post-M1 consumers land.

Evidence maintenance follow-up (P035-012)

The primary local evidence store alone has one failure domain. P035-012 now qualifies the operator-adopted mirrored secondary and a manual candidate-bound verification procedure. Before every release, preparation must freshly retrieve and verify each selected externally retained bundle from both adopted locations: ordinary qualification for complete runs, cause verification for refusal capsules. Record exact bundle/tool identities and results. An old successful receipt does not establish current availability; a missing or corrupt bundle blocks its evidence claim. The domain procedure belongs to Node's docs/evidence/EXTERNAL-RETENTION.md.

P035-012 records the explicit retention owner and fresh destination qualification before any reviewed retirement. Replica protection is a relation between two observed physical failure domains; another directory or APFS sibling volume is insufficient. The operator accepted an overlapping mirror with an online member on a different physical device: this qualifies primary-media-loss protection, with shared first member, host and mirror-management risks explicitly retained, rather than disjoint media. The release owner binds both fresh reads to a clean candidate, selected evidence inventory and current trusted tools. S020 does not interpret release evidence or store layout. A future periodic verification job can use S020's existing host-owned job contract, with bounded execution and visible failure; the scheduler must not learn store layout or scenario predicates. No periodic job is configured. Actual recovery and the separate release-gate rehearsal are retained at node:docs/evidence/matrix-opaque-envelope/2026-10-20-replica-recovery/README.md; independent-host and disjoint-media protection are not claimed.

P035-014 now tracks the separate periodic supervision gap: bounded topology/member checks, rotating fresh verification at both locations and explicit stale-job state, with S039 operator degradation/recovery notifications. Current P035-012 receipts are point-in-time observations only. Scheduling owns cadence and bounded execution; storage owns topology/integrity and the release owner still requires a complete fresh candidate-bound read. An absent or overdue job cannot report protection as healthy. No job or notification delivery is installed or qualified by this entry.

Responsibility maintenance consumer — 2026-10-23

M4/M5 now reuse the host-owned S020 action path for bounded maintenance continuation and recipient-bound alert delivery. The maintenance ledger owns admitted commands, original deadlines, attempts, budgets, stop requests and outcomes; S029 is its rebuildable deferred read model. The scheduler launches bounded owner work and does not become a maintenance authority, retention owner or case-procedure timer.

These adapters have scoped owner conformance; a separate final Q passage now qualifies its named local continuation, outage/restart, delivery and v1-availability cases. This entry does not close P051-007 case deadlines or P051-013 repair reviews. Maintenance remains disabled by default, v1 remains authoritative and all D7 components remain false. See node:docs/evidence/local-accountability/2026-10-23-maintenance-shadow/passage-1/README.md. Synthetic clock/incarnation inputs and the maintenance consumer do not qualify case-procedure scheduling, portable restore or release readiness.

  • 020-scheduler-caps.edn

Recovery attention source job (P035-013, 2026-10-23)

The accepted job is daemon-owned, nonoverlapping and bounded to one 64-fact source page per five-second launch. Agora owns facts and recovery; S039 owns queue policy and attention state. The adapter advances its durable cursor only after durable S039 acceptance and schedules fresh deadline inspection without executing retry. Delivery failure does not hold Matrix sync or publication. The daemon registers this source job, and focused qualification at clean Node 885a78fd / Orbidocs b16312f6 on 2026-10-23 proves durable delivery before cursor advancement, crash/restart idempotency and deadline inspection without automatic retry. See node:docs/evidence/matrix-opaque-envelope/2026-10-23-recovery-attention/README.md. This consumer does not qualify the separate P035-014 mirror-supervision job.

Optional module jobs (P035-014, accepted 2026-10-23)

The generic module-job adapter binds an admitted job to the currently active middleware module, operation and host-approved execution budget. Resolve current readiness/activation on each launch, including run-once, without holding the supervisor lock over I/O. Package fragments cannot claim another module's jobs. Module revocation stops new launches; ordinary node profiles are unchanged. scheduled-module-job-request.v1 and scheduled-module-job-result.v1 bind job, launch and budget. S020 knows no evidence-store paths, Python or qualifier logic. The generic adapter is implemented, conformance-tested and qualified through the focused P035-014 real background, periodic, restart and S039 consumer path. The 2026-10-23 proof at node:docs/evidence/matrix-opaque-envelope/2026-10-23-replica-supervision/README.md covers eleven cases and eighteen fresh store/identity pairs. This optional session-bound consumer does not enable jobs in normal node profiles or qualify release readiness.

The accepted module-job channel uses host-only scheduled-job.invoke frames, with the scheduled request/result contracts. It is distinct from ordinary middleware.invoke and the read-only module HTTP bridge: a caller cannot turn a status capability into a probe by supplying a scheduler-shaped body. The job owner is the admitted component ID; the authenticated target determines its separate module ID. Existing v1 frames are unchanged; v2 declares the new operation.

Generic module-job authority, deadline and failure contract

The local operator configures/adopts jobs and their execution budgets. Admission binds the component, its current executor and exact operation; a module report or package fragment cannot grant itself another component's job. The host checks current activation and readiness for every launch, including run-once. Execution budgets are 1 ms–1 hour; the channel timeout is capped by the remaining launch budget. Normal scheduler concurrency, overlap and missed-window policies apply.

A receiver of scheduled-module-job-request.v1 must finish its response before budget/remaining-ms expires and settle launch-owned work, including child cleanup, within that bound. The host's deadline is authoritative. The field is an upper bound, not an extension of time spent in transport or a queue. A module must reserve response/cleanup time and use its own monotonic clock; it must not launch work it cannot safely contain. A timeout ends the host call; it does not prove the module stopped or that no effect occurred. Effectful consumers therefore own idempotency, recovery and fencing rather than relying on scheduler cancellation.

AuthorizationDenied means current admission/activation or the configured target binding refused before dispatch. Transient means the channel call was unavailable or timed out, with outcome potentially unknown; it is not a domain refusal or a proof of no work. Invalid request/result or mismatched job/launch identity is InvalidConfig; interrupted/deadline-expired launches retain their distinct scheduler errors. The durable execution ledger/status exposes those failures. The host may count deadline overruns but cannot preempt arbitrary in-module work.

This is a generic host-to-module execution surface, not a host capability granted to ordinary middleware. See Proposal 072's scheduler/channel boundary; evidence supervision is one optional consumer, not its contract owner.

The post-qualification P035-014 identity delta separately checks the unchanged host adapter with portable native media, OS-access baseline mismatch/S039 and restart. It does not renew the full periodic/rotation profile; the original proof remains historical. Review evidence: node:docs/evidence/matrix-opaque-envelope/2026-10-23-replica-identity-review/README.md.

Local deadline and channel-containment follow-up — 2026-10-24

The generic adapter refuses a remaining interval below one representable wire millisecond as DeadlineExceeded before schema admission or dispatch; it does not round up time or classify this as invalid operator configuration. The Python channel SDK has an explicit optional deadline-aware handler port. It converts the original frame deadline once before worker queueing, preserves the original payload and rechecks that same monotonic cut before invocation. Legacy handler signatures and normal scheduler budgets remain unchanged.

The evidence-supervision consumer bounds its immutable launch deadline by both that ingress cut and the request's remaining budget. Validation, queueing, preparation, child startup, native work and cleanup spend that interval; another worker cannot receive a renewed slot. A store not observed within the slot stays unknown. The Rust channel's full response queue retires the existing session instead of blocking teardown; a lost response is an unknown outcome, never an automatic replay or evidence that a domain effect was rolled back.

Regression results belong to node:docs/audits/RESPONSIBILITY-PRIMARY-INTEGRATION-2026-10-24.md. These are implementation/integration checks, not renewal of P035-014's historical session-bound runtime proof or Responsibility Q, and they do not qualify release readiness, native OS preemption or off-session supervision.

P076-037 Messaging status refresh

S020 owns the messaging-issuance-status-refresh job: a 60-second interval, 60-second initial delay, stable jitter up to five seconds, skip-missed and skip-overlap behavior, rotating batches and at most four parallel status-source calls. The P091 Messaging acquisition policy is checked by the source on each call. Pausing or disabling this job is visible in Messaging readiness and does not revoke a signed lease that is still valid. Signed parent/child withdrawal publication has a distinct bounded retry worker outside S020 so that pausing status refresh cannot suppress protective publication. See P076-037.

P076-038 keeps this job active during physical mode windows and attributes its status queries by the owner-recorded acquisition reason. A scheduled query is separate from the send-triggered peer preflight, so a window can have zero holder queries on demand even when S020 performs its allowed refresh.

P076-038 qualification checkpoint — 2026-10-28

P076-038 left S020 refresh active in physical policy windows and attributed its HTTP attempts by acquisition reason. The scheduled-only holder's exact observed grant was blocked at its forwarder while own-grant refresh remained available. Child/parent withdrawals each passed counted publication failure and independent worker retry with refresh paused. This preserves the two lifecycle owners; see P076-038 and node:docs/audits/ACCEPTANCE-P076-038-2026-10-28.md for exact pins.

Dormant-fact resonance jobs

Planned (2026-10-27). Story 014 and its follow-ups need three consumer-owned jobs. S020 owns only their clock and launch policy; each owner keeps its budgets, refusal reasons and readiness reporting.

Job Owner Cadence Task
Retention expiry Memarium Daily, skip-missed P036-005
Dormant-fact scan, generalization and scoring Weak Signal Harvester module Per epoch; scoring after a completed pull P078-010–012
Bucket pull Whisper Open the epoch window, skip-overlap; execute persisted Whisper-owned offsets P013-DFR-002

The pull job reads the interest profile and vocabulary resolution current at the epoch boundary, so writing a fact never triggers network activity. Pausing any of these jobs is visible in its owner's readiness; pausing expiry postpones erasure rather than skipping it.

The bucket pull executes the compiled jobs for all plan entries, whatever their need, decoy or cover origin, at a time drawn by the shared cover-schedule/v1 rule (P013-CIM-003). Whisper coalesces duplicate bucket/window requests before sampling and persisting one offset per executable job, as specified in its plan recommendations. The S020 launch only opens the epoch's pull window; these offsets belong to the Whisper job, so the scheduler sees no origin.

No second jitter or offset draw is applied by S020 on replay or retry.

Artifact Delivery maintenance jobs

Minimal-trace cleanup is an AD retention obligation, independent of dormant-fact resonance. S020 dispatches the due work; AD owns holds, erasure and diagnostics.

Job Owner Cadence Task
Minimal-trace purge Artifact Delivery After the retry horizon, skip-missed S023-002

Responsibility V4-prep boundary — 2026-10-30

V4-prep qualifies bounded host-owned due-resume materialization only in the isolated lifecycle fixture owner, outside admission. Read-only composition uses the original resume deadline even if materialization cannot commit. This adds no production S020 job or dispatch authority and changes no existing scheduler budget. The maintenance/shadow qualification remains scoped to its original profile; V4s/V5 require explicit live owner integration and fresh evidence. See node:docs/evidence/local-accountability/2026-10-30-v4-prep/README.md.

Local assessment audit consumer (2026-10-30)

The P026 audit job assessment-audit-retention is locally qualified with ordinary run-once and terminal owner settlement, separately from explicit-time retirement. Cadence is 900 seconds with at most 60-second jitter and SkipIfRunning. The domain limits new work to sixteen units, 4 MiB and 250 ms before starting further work; a started fsync/transaction is not preempted. S020 remains the only cadence owner. The P026 stage closeout pins Node da1d14a7 / Orbidocs 127843fb, five ordinary cases and 172 separate component checks with 70 controls per mode/location. The capability catalog is unchanged: this composes existing owner ports and scheduling, and adds no generic grant-bearing operation. Historical evidence, unknown coverage, models and release scope remain separate.

Whisper private-case owner maintenance

Optional native case-authority and protected-signal custodian adoptions register separate component-local jobs: whisper-case-authority.maintenance owned by whisper-case-authority, and whisper-protected-signal.maintenance owned by whisper-protected-signal. The daemon launch gate requires that exact pair and a Running host; module channels and unrelated owners cannot invoke either action. No job is installed by the default disabled role.

Both use a ten-second cadence, a five-second cooperative launch budget, SkipMissed and SkipIfRunning. Authority negative-knowledge reconciliation and expiry stay in the case owner; public offer-control expiry stays in its separate fenced owner. S020 receives counts and coarse failures, never private payloads. The shared direct receive executor performs no maintenance for these owners. Disabled owner cleanup remains the existing bounded retention operation, without signing authority or fresh owner initialization. Scheduler acceptance does not prove peer delivery, case opening, physical erasure or complete private-exchange Gate A/B. See node:daemon/docs/RELAY-DELIVERY.md and the private-case execution profile.