thinkpool-pair 0.7.357 → 0.7.359

package/bridge.mjs

@@ -129,11 +129,13 @@ import { createStandalonePairResponder, standalonePairIdentity } from './direct-
 import { dispatchPendingRecap, recoverInterruptedTurn, recoverMissingResumeOnce, sendInterruptedContinue, shouldAttemptNativeResume, supersedeInterruptedResume } from './interrupted-resume.mjs'
 import { supersedeDispatchLease } from './dispatch-lease.mjs'
 import { realtimeRecoveryDecision, turnInFlight } from './update-gate.mjs'
-import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, hasDurableArchive, servesHistoryPage } from './session-store.mjs'
+import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, hasDurableArchive, servesHistoryPage, acknowledgePendingScheduledOutcome, commitRecordedScheduledOutcome, deletePendingScheduledOutcome, loadPendingScheduledOutcome, loadPendingScheduledOutcomes, savePendingScheduledOutcome } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, ImageEventQueue, imageQueueConfig, uploadCodeImage as uploadCodeImageRequest, usageReportLine, codexUsageReportLine, appendCurrentPersonRequest, buildRecapFromLog, RECAP_CAP, trimmedBeforeSeq, firstSeq } from './event-id.mjs'
 import { createLatestReplayPump, requestedReplayIds } from './replay-transport.mjs'
 import { classifyCodeEvent, unknownCodeEventNotice } from './code-event-contract.mjs'
 import { fetchPairControlDeliveryAuthority } from './pair-control-authority.mjs'
+import { finishScheduledRunWithRetry, pollDueScheduledRuns, sanitizeScheduledOutcomeIntent, scheduledOutcomeReconciliationComplete, scheduledRunDeadlineRequired, scheduledRunSpawnAdmission, scheduledRunsCapability, scheduledRunsEnabled } from './scheduled-runs.mjs'
+import { acquireScheduledRunAdmission, releaseScheduledRunAdmission } from './scheduled-run-admission.mjs'
 import { SIDE_HANDOFF_PROMPT, SIDE_ROLE_PROMPT, appendSideContext, assistantTextSince, dispatchSideContexts, sideContextBlock, sideSnapshot } from './side-lane.mjs'
 import { acknowledgeWorkerCompletions, enqueueWorkerCompletion, workerCompletionPrompt, workerCompletionRecord } from './worker-completion.mjs'
 import { planMeterLine } from './plan-meters.mjs'
@@ -664,6 +666,11 @@ if (process.stdin.isTTY && !headless && process.env.THINKPOOL_PAIR_AUTOUPDATE !=
 }
 const name = process.env.TP_NAME || os.userInfo().username || 'host'
 const BRIDGE_ID = (randomUUID?.().slice(0,8)) || 'bridgexx'
+// The room child has its own short local id for terminal/pair-control authority.
+// Scheduled execution additionally needs the supervisor's UUID claim, inherited only
+// by account-owned children; standalone/anon bridges deliberately cannot run schedules.
+const ACCOUNT_BRIDGE_ID = process.env.TP_ACCOUNT_BRIDGE_ID || null
+const ACCOUNT_BRIDGE_FENCING = Number.parseInt(process.env.TP_ACCOUNT_BRIDGE_FENCING || '', 10)
 const BRIDGE_STARTED_AT = Date.now()
 // host: this machine's short label — os.hostname() with any DNS/domain suffix
 // stripped and capped ~24 chars. A /code room can be served by different bridges
@@ -1392,6 +1399,9 @@ const announce = () => {
     // updir: where room file-drops land (forward-slash normalised — the web
     // client string-joins host paths onto it; Node accepts `/` on Windows).
     updir: UPDIR.split(path.sep).join('/'),
+    // Secret-free host opt-in projection for Automations. Never announce auth,
+    // fencing, credentials, endpoints, prompts, or schedule contents.
+    scheduledRuns: scheduledRunsCapability(),
     // canResume: this agent can continue a prior session in THIS cwd —
     // re-probed per announce (a fresh run creates a session, so the flag
     // can flip true while the bridge is up). Functions don't survive
@@ -1414,7 +1424,7 @@ const announce = () => {
       // laneStatusOf: authoritative busy/idle + last-action timestamp/age +
       // STUCK/BLOCKED alert. The bridge owns the turn and permission state, so
       // every roster consumer reads one status instead of reconstructing it.
-      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, ...laneStatusOf(s), turnRev: Number(s._turnRev) || 0, ...(laneBusyOf(s) && s._turnStart ? { turnStartedAt: s._turnStart } : {}), ...(!laneBusyOf(s) && Number(s._settledTurnRev) > 0 && Number(s._settledTurnRev) === Number(s._turnRev) ? { settledTurnRev: Number(s._settledTurnRev), turnSettledAt: Number(s._turnSettledAt) || undefined } : {}), hasTranscript: s.log.length > 0, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, capabilities: { ...structuredRuntimeMetadata(s.runtime || 'claude'), modes: structuredModesForLane(s.runtime || 'claude', s) }, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [], canSteer: s.session?.canSteer ?? false } : s.runtime === 'hermes' ? { models: s.models || [], canSteer: s.session?.canSteer ?? false } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.sideParent ? { sideParent: s.sideParent, sideTask: s.sideTask || undefined, sideHandback: !!s.sideHandback } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}),
+      ...[...sessions.entries()].map(([id, s]) => ({ id, cmd: s.cmd, kind: 'structured', runtime: s.runtime || 'claude', alive: true, ...laneStatusOf(s), turnRev: Number(s._turnRev) || 0, ...(laneBusyOf(s) && s._turnStart ? { turnStartedAt: s._turnStart } : {}), ...(!laneBusyOf(s) && Number(s._settledTurnRev) > 0 && Number(s._settledTurnRev) === Number(s._turnRev) ? { settledTurnRev: Number(s._settledTurnRev), turnSettledAt: Number(s._turnSettledAt) || undefined } : {}), hasTranscript: s.log.length > 0, commands: s.commands, mode: s.mode || undefined, effort: s.effort || undefined, name: termNames[id] || undefined, model: s.model || undefined, capabilities: { ...structuredRuntimeMetadata(s.runtime || 'claude'), modes: structuredModesForLane(s.runtime || 'claude', s) }, ...(s.runtime === 'codex' ? { approvalPolicy: codexConfigForMode(s.mode).approvalPolicy, models: s.models || [], canSteer: s.session?.canSteer ?? false } : s.runtime === 'hermes' ? { models: s.models || [], canSteer: s.session?.canSteer ?? false } : {}), ...(s.archiveOldestSeq != null ? { oldestSeq: s.archiveOldestSeq } : {}), ...(s.spawnedBy ? { spawned: true, spawnedBy: s.spawnedBy } : {}), ...(s.sideParent ? { sideParent: s.sideParent, sideTask: s.sideTask || undefined, sideHandback: !!s.sideHandback } : {}), ...(s.flowSessionId ? { flowId: s.flowSessionId, flowRole: s.flowTaskKey ? 'lane' : 'conductor' } : {}), ...(s.scheduleRunId ? { scheduleRunId: s.scheduleRunId } : {}),
         // provider: the registered LLM-provider this lane runs on, NAME-ONLY {id,name}
         // (NEVER the key or baseUrl). Additive; older clients ignore it. Omitted for the
         // built-in/default Claude path (no badge). Makes the lane's provider badge +
@@ -1568,7 +1578,10 @@ function attachDurablePermissionSource(entry, payload) {
   }
   pushLog(entry, event)
   bcast('code-event', { term: entry.id, evt: event })
-  return { ...payload, source: { epoch: 0, cid: event.cid, seq: event.seq } }
+  // Schedule provenance is opaque and bounded; the browser's existing durable
+  // pair-control projection carries it into request_context. It is never prompt,
+  // path, credential, or tool argument data.
+  return { ...payload, ...(entry.scheduleRunId ? { runId: entry.scheduleRunId } : {}), source: { epoch: 0, cid: event.cid, seq: event.seq } }
 }
 // ── Tier 3 — raise a standalone permission card on a target session ──────────
 // The cross-ROOM post lands here on the RECEIVING side: a person in THIS room must
@@ -1755,6 +1768,149 @@ const designArtifacts = new Map() // previewId → trusted source record
 const designQueues = new Map()    // producer term → validated requests
 const designActive = new Map()    // producer term → request awaiting result + proof
 const designRestore = new Map()   // current previewId → immediately previous verified record/edit
+function scheduledEvidenceForTerm(terminalId) {
+  return [...designArtifacts.values()]
+    .filter((record) => record?.term === terminalId && typeof record.previewId === 'string')
+    .slice(0, 16).map((record) => ({ type: 'preview', id: record.previewId }))
+}
+function clearScheduledRunDeadline(entry) {
+  if (entry?.scheduleDeadlineTimer) clearTimeout(entry.scheduleDeadlineTimer)
+  if (entry) entry.scheduleDeadlineTimer = null
+}
+const scheduledOutcomeWrites = new Set()
+async function releaseScheduledAdmissionForEntry(entry) {
+  const lease = entry?.scheduleAdmissionLease
+  if (!lease) return true
+  const released = await releaseScheduledRunAdmission(lease)
+  if (!released.ok) return false
+  entry.scheduleAdmissionLease = null
+  return true
+}
+async function persistScheduledRunOutcome(entry) {
+  const intent = sanitizeScheduledOutcomeIntent(entry?.scheduleOutcomePending)
+  if (!entry?.id || !intent || entry.scheduleOutcomeRecorded) return false
+  const key = `${entry.id}:${intent.runId}`
+  if (scheduledOutcomeWrites.has(key)) return false
+  scheduledOutcomeWrites.add(key)
+  try {
+    const written = await finishScheduledRunWithRetry({
+      supabaseUrl: SUPABASE_URL, anonKey: SUPABASE_ANON, token: codeAuthToken, roomCode: room,
+      runId: intent.runId, bridgeId: ACCOUNT_BRIDGE_ID, bridgeFencing: ACCOUNT_BRIDGE_FENCING,
+      result: intent.result, canceled: intent.canceled, evidenceRefs: intent.evidenceRefs,
+    })
+    if (!written.ok) return false
+    // The durable occurrence is now terminal, so it no longer consumes the
+    // host-wide scheduled-run capacity. A failed local release remains leased
+    // until its exact deadline and is retried from the restored session.
+    await releaseScheduledAdmissionForEntry(entry)
+    const liveEntry = sessions.get(entry.id) === entry
+    if (!liveEntry) {
+      // Closed terminals have no live snapshot to preserve. Their independent
+      // outbox is the only local replay boundary. Tombstone the acknowledged
+      // exact run before deletion so a failed delete can never re-finish it.
+      if (!acknowledgePendingScheduledOutcome(room, entry.id, intent.runId)) return false
+      return deletePendingScheduledOutcome(room, entry.id)
+    }
+    const priorPending = entry.scheduleOutcomePending
+    entry.scheduleOutcomeRecorded = true
+    entry.scheduleOutcomePending = null
+    const committed = commitRecordedScheduledOutcome(room, entry.id, () => entry.flush?.())
+    if (!committed.snapshotRecorded) {
+      // The remote finish is idempotent. Retain the durable outbox and restore
+      // in-memory pending state so reconciliation retries the whole commit.
+      entry.scheduleOutcomeRecorded = false
+      entry.scheduleOutcomePending = priorPending
+      return false
+    }
+    // If deleting the outbox failed, keep the durably recorded live state. The
+    // next reconciliation pass recognizes this exact run and retries deletion
+    // without issuing another finish RPC.
+    return committed.ok
+  } finally {
+    scheduledOutcomeWrites.delete(key)
+  }
+}
+function recordScheduledRunOutcome(entry, result, { canceled = false } = {}) {
+  if (!entry?.scheduleRunId || entry.scheduleOutcomeRecorded || entry.scheduleOutcomePending) return false
+  const intent = sanitizeScheduledOutcomeIntent({
+    runId: entry.scheduleRunId,
+    result,
+    canceled,
+    evidenceRefs: scheduledEvidenceForTerm(entry.id),
+  })
+  if (!intent) return false
+  if (!savePendingScheduledOutcome(room, entry.id, intent)) return false
+  entry.scheduleOutcomePending = intent
+  clearScheduledRunDeadline(entry)
+  entry.flush?.()
+  void persistScheduledRunOutcome(entry)
+  return true
+}
+async function recoverPendingScheduledRunOutcomes() {
+  if (!codeAuthToken || !ACCOUNT_BRIDGE_ID || !Number.isSafeInteger(ACCOUNT_BRIDGE_FENCING) || ACCOUNT_BRIDGE_FENCING < 1) return false
+  const savedRecords = new Map(loadAll(room).map((record) => [record?.id, record]).filter(([id]) => id))
+  for (const { terminalId, intent: stored, acknowledged } of loadPendingScheduledOutcomes(room)) {
+    // A durable acknowledgement tombstone is delete-only. It remains
+    // authoritative even after the terminal snapshot has been archived.
+    if (acknowledged) {
+      deletePendingScheduledOutcome(room, terminalId)
+      continue
+    }
+    const intent = sanitizeScheduledOutcomeIntent(stored)
+    if (!intent) { deletePendingScheduledOutcome(room, terminalId); continue }
+    let entry = sessions.get(terminalId)
+    const saved = savedRecords.get(terminalId)
+    // An acknowledged finish can leave its exact outbox behind if local
+    // deletion failed after the recorded snapshot commit. Clean only that
+    // exact run; never re-finish or reinterpret it.
+    const recordedRunId = entry?.scheduleOutcomeRecorded === true ? entry.scheduleRunId
+      : saved?.scheduleOutcomeRecorded === true ? saved.scheduleRunId
+        : null
+    if (recordedRunId === intent.runId) {
+      deletePendingScheduledOutcome(room, terminalId)
+      continue
+    }
+    // A live snapshot that has not restored yet is not a closed terminal. Wait
+    // for the restore loop instead of racing it with a synthetic holder.
+    if (!entry && saved) continue
+    if (entry && entry.scheduleRunId && entry.scheduleRunId !== intent.runId) continue
+    if (!entry) entry = { id: terminalId, scheduleRunId: intent.runId, scheduleOutcomeRecorded: false }
+    entry.scheduleOutcomePending = intent
+    await persistScheduledRunOutcome(entry)
+  }
+  return scheduledOutcomeReconciliationComplete(loadPendingScheduledOutcomes(room))
+}
+function armScheduledRunDeadline(entry) {
+  clearScheduledRunDeadline(entry)
+  if (!scheduledRunDeadlineRequired({
+    runId: entry?.scheduleRunId,
+    deadlineAt: entry?.scheduleDeadlineAt,
+    outcomeRecorded: entry?.scheduleOutcomeRecorded,
+    outcomePending: entry?.scheduleOutcomePending,
+  })) return
+  const remaining = Math.max(0, entry.scheduleDeadlineAt - Date.now())
+  entry.scheduleDeadlineTimer = setTimeout(async () => {
+    entry.scheduleDeadlineTimer = null
+    if (entry.scheduleOutcomeRecorded) return
+    entry.scheduleTimedOut = true
+    // Settle every local permission promise before aborting the runtime. Otherwise
+    // a permission card can keep the deadline path hung or later win classification.
+    drainPending(entry)
+    await queueAbortBarrier(entry)
+    const evt = { kind: 'error', subtype: 'runtime_limit', message: 'Scheduled run reached its configured runtime ceiling.' }
+    pushLog(entry, evt)
+    bcast('code-event', { term: entry.id, evt })
+    recordScheduledRunOutcome(entry, evt)
+    entry.flush?.()
+    announce()
+  }, remaining)
+  entry.scheduleDeadlineTimer.unref?.()
+}
+// Realtime can carry the settled DOM for ordinary authored mockups. Including
+// that already-uploaded snapshot in the correlated verified-live event lets an
+// open Design lane advance revisions without a second auth/sign/download round
+// trip. Large artifacts keep the normal signed-storage path.
+const MAX_INLINE_DESIGN_REVISION_BYTES = 128 * 1024
 const designStatus = (payload) => designChannel.send({
   type: 'broadcast', event: 'design-status', payload: { ts: Date.now(), ...payload },
 })
@@ -1777,7 +1933,12 @@ const finishDesign = (term, state, extra = {}) => {
 const maybeVerifyDesign = (term) => {
   const active = designActive.get(term)
   if (!active?.resultOk || !active.proof) return
-  finishDesign(term, 'verified-live', { message: 'Verified at desktop and mobile.', artifact: active.proof, canRestore: active.record.sourceKind !== 'preview' })
+  finishDesign(term, 'verified-live', {
+    message: 'Verified at desktop and mobile.',
+    artifact: active.proof.artifact,
+    ...(active.proof.artifactHtml ? { artifactHtml: active.proof.artifactHtml } : {}),
+    canRestore: active.record.sourceKind !== 'preview',
+  })
 }
 
 function pumpDesign(term) {
@@ -1883,6 +2044,20 @@ const handleManifest = async ({ box, term, trustedDesignSource = false, slug, m
   const displaySource = designRecord
     ? resolveManifestDisplaySource(m, designRecord, { box })
     : null
+  const activeDesignRequest = designRecord ? designActive.get(term) : null
+  const correlatedDesignRequest = !!(activeDesignRequest
+    && m.designRequestId === activeDesignRequest.request.cid
+    && m.parentRevision === activeDesignRequest.record.revision)
+  const expectedDesignRevision = activeDesignRequest?.restoreRecord?.revision
+  const designRevisionProvesChange = expectedDesignRevision
+    ? designRecord?.revision === expectedDesignRevision
+    : designRecord?.revision !== activeDesignRequest?.record?.revision
+  const sameDesignTarget = activeDesignRequest?.record?.sourceKind === 'preview'
+    ? designRecord?.sourceKind === 'preview' && designRecord?.captureKey === activeDesignRequest.record.captureKey
+    : designRecord?.sourcePath === activeDesignRequest?.record?.sourcePath
+  const verifiedParentRevision = correlatedDesignRequest && sameDesignTarget && designRevisionProvesChange
+    ? activeDesignRequest.record.revision
+    : null
   // 2026-07-07: these used to swallow read errors silently — a transient
   // unreadable file (race with the render script, permissions, mid-write)
   // meant the manifest still POSTed with that field missing, and nothing
@@ -1919,6 +2094,7 @@ const handleManifest = async ({ box, term, trustedDesignSource = false, slug, m
         code: room, slug: m.slug, title: m.title, cid, ts: deliveryTs, term,
         desktopPng: readB64(m.desktop), mobilePng: readB64(m.mobile), html: designRecord ? displaySource : readTxt(m.html),
         ...(designRecord ? { previewId: designRecord.previewId, revision: designRecord.revision, sourceKnown: true } : {}),
+        ...(verifiedParentRevision ? { verified: true, parentRevision: verifiedParentRevision } : {}),
       }),
     })
     if (!res.ok) {
@@ -1928,8 +2104,17 @@ const handleManifest = async ({ box, term, trustedDesignSource = false, slug, m
     const uploaded = await res.json()
     const { paths } = uploaded
     const designAccepted = !!(designRecord && uploaded?.payload?.sourceKnown)
+    const verifiedDesignRevision = !!(designAccepted
+      && verifiedParentRevision
+      && uploaded?.payload?.verified === true
+      && uploaded.payload.parentRevision === verifiedParentRevision)
     const artifact = { kind: 'mockup', __struct: true, cid, term, slug: m.slug, title: m.title || m.slug, ts: deliveryTs, paths,
-      ...(designAccepted ? { previewId: designRecord.previewId, revision: designRecord.revision, sourceKnown: true } : {}) }
+      ...(designAccepted ? {
+        previewId: designRecord.previewId,
+        revision: designRecord.revision,
+        sourceKnown: true,
+        ...(verifiedDesignRevision ? { verified: true, parentRevision: verifiedParentRevision } : {}),
+      } : {}) }
     if (designAccepted) {
       Object.assign(designRecord, { term, slug: m.slug, title: m.title || m.slug, desktop: m.desktop, mobile: m.mobile })
       try {
@@ -1939,17 +2124,15 @@ const handleManifest = async ({ box, term, trustedDesignSource = false, slug, m
         if (!fs.existsSync(designRecord.backupPath)) fs.writeFileSync(designRecord.backupPath, designRecord.source)
       } catch { /* restore stays unavailable if the host backup cannot be written */ }
       designArtifacts.set(designRecord.previewId, designRecord)
-      const active = designActive.get(term)
-      const correlated = active && m.designRequestId === active.request.cid && m.parentRevision === active.record.revision
+      const active = activeDesignRequest
+      const correlated = verifiedDesignRevision
       const dual = !!(paths?.html && paths?.desktop && paths?.mobile && m.desktop && m.mobile)
-      const expectedRevision = active?.restoreRecord?.revision
-      const revisionProvesChange = expectedRevision ? designRecord.revision === expectedRevision : designRecord.revision !== active?.record?.revision
-      const sameTarget = active?.record?.sourceKind === 'preview'
-        ? designRecord.sourceKind === 'preview' && designRecord.captureKey === active.record.captureKey
-        : designRecord.sourcePath === active?.record?.sourcePath
-      if (correlated && dual && sameTarget && revisionProvesChange) {
+      if (correlated && dual) {
         if (active.record.sourceKind !== 'preview') designRestore.set(designRecord.previewId, { priorRecord: active.record, request: active.request })
-        active.proof = artifact
+        const artifactHtml = Buffer.byteLength(displaySource, 'utf8') <= MAX_INLINE_DESIGN_REVISION_BYTES
+          ? displaySource
+          : null
+        active.proof = { artifact, artifactHtml }
         maybeVerifyDesign(term)
       }
     }
@@ -2238,6 +2421,80 @@ function restoredTurnOpen(log) {
   return false
 }
 
+function emitCodexCompactionControl(entry, text, by = null) {
+  const evt = { kind: 'control', text, by }
+  pushLog(entry, evt)
+  bcast('code-event', { term: entry.id, evt })
+}
+
+async function runCodexCompaction(entry, request = {}) {
+  const recap = buildRecapFromLog(entry.log, RECAP_CAP, { reason: 'compact' })
+  if (!recap) {
+    emitCodexCompactionControl(entry, 'nothing to compact — context unchanged', request.by)
+    return
+  }
+  const preTokens = entry.lastUsage?.ctx?.used || null
+  bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
+  let nativeCompacted = false
+  try {
+    nativeCompacted = await entry.session.compactContext?.()
+  } catch {
+    // compactContext classifies delivery certainty. A truly unexpected throw
+    // remains non-replayable here; resetting after an unknown native request can
+    // execute compaction twice against two different threads.
+    nativeCompacted = null
+  } finally {
+    // Native compaction emits usage while compactActive=true, so onEvent
+    // legitimately announces a busy edge. It has no ordinary result event;
+    // close that borrowed edge after compactContext clears compactActive.
+    if (!entry.session.turnActive && settleLaneControl(entry)) announce()
+  }
+  if (nativeCompacted === true) {
+    const evt = { kind: 'compaction', trigger: 'manual', preTokens, by: request.by, native: true }
+    pushLog(entry, evt)
+    bcast('code-event', { term: entry.id, evt })
+    bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+    entry.flush?.()
+    return
+  }
+  if (nativeCompacted == null) {
+    bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+    emitCodexCompactionControl(entry, 'Native compaction is still settling; existing context was preserved.', request.by)
+    entry.flush?.()
+    return
+  }
+  if (entry.session.clearContext?.() === false) {
+    bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+    emitCodexCompactionControl(entry, 'Codex context compaction unavailable right now', request.by)
+    return
+  }
+  entry.pendingRecap = recap
+  const evt = { kind: 'compaction', trigger: 'manual', preTokens, by: request.by }
+  pushLog(entry, evt)
+  bcast('code-event', { term: entry.id, evt })
+  // The new native thread has only the bounded recap queued for the next human
+  // turn. Reset the visible meter to that conservative text estimate.
+  if (entry.lastUsage?.ctx?.max) {
+    const used = Math.ceil(recap.length / 4)
+    const max = entry.lastUsage.ctx.max
+    const usage = { kind: 'usage', ctx: { ...entry.lastUsage.ctx, used, max, pct: Math.min(100, Math.round((used / max) * 100)), over: used > max } }
+    entry.lastUsage = usage
+    bcast('code-event', { term: entry.id, evt: usage })
+  }
+  bcast('code-event', { term: entry.id, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
+  entry.flush?.()
+}
+
+function startCodexCompaction(entry, request = {}) {
+  if (!entry || entry.runtime !== 'codex' || entry.codexCompactionPromise) return false
+  const job = runCodexCompaction(entry, request)
+  entry.codexCompactionPromise = job
+  void job.finally(() => {
+    if (entry.codexCompactionPromise === job) entry.codexCompactionPromise = null
+  }).catch(() => { /* runCodexCompaction already surfaced classified failures */ })
+  return true
+}
+
 // Active-worktree snapshot for the per-turn ROOM NOW tail. Cached ~60s per cwd —
 // a subprocess on every turn of every lane would be waste, and worktrees change on
 // minutes-scale. Plain `git worktree list` output (path · sha · [branch]) is the
@@ -2266,7 +2523,7 @@ function worktreeSnapshot(cwd) {
 // relay STRUCTURED events. onEvent → broadcast `code-event` + print locally +
 // persist to the host file; tool calls round-trip through the perm card; the
 // rolling log replays to joiners and survives bridge restarts (session-store).
-function openStructured({ id, runtime = 'claude', model, models, effort, resume, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, pendingWorkerCompletions, workerCompletionsInFlight, rolePrompt, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage, receivedTurnCids }) {
+function openStructured({ id, runtime = 'claude', model, models, effort, resume, log, commands, mode, spawnedBy, spawnDepth, cascadeRole, hop, sideParent, sideTask, pendingSideContexts, pendingWorkerCompletions, workerCompletionsInFlight, rolePrompt, sliceType, flowSessionId, flowTaskKey, flowRole, flowReviewTarget, flowReviewTargets, flowReviewSnapshots, flowReviewRound, dispatchBaseSha, revertTarget, cwd, managedWorktree, reviewSliceRoots, openedAt, defer, provider, carryRecap, lastUsage, receivedTurnCids, scheduleRunId, scheduleDeadlineAt, scheduleOutcomeRecorded, scheduleAdmissionLease }) {
   if (sessions.has(id)) return
   runtime = structuredRuntimeMetadata(runtime) ? runtime : 'claude'
   // Fail closed before exposing a native lane if its bridge semantic contract
@@ -2313,6 +2570,12 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
   const restoredRawLog = Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : []
   const restoredLog = boundStructuredLog(restoredRawLog)
   const restoredOffset = restoredRawLog.length - restoredLog.length
+  const restoredScheduleOutcomeCandidate = scheduleRunId && scheduleOutcomeRecorded !== true
+    ? sanitizeScheduledOutcomeIntent(loadPendingScheduledOutcome(room, id))
+    : null
+  const restoredScheduleOutcome = restoredScheduleOutcomeCandidate?.runId === scheduleRunId
+    ? restoredScheduleOutcomeCandidate
+    : null
   const entry = { cmd: runtime, runtime, kind: 'structured', log: restoredLog, pending: new Map(), receivedTurnCids: new Set(Array.isArray(receivedTurnCids) ? receivedTurnCids.filter(Boolean).slice(-1000) : []), session: null, recovered: false, commands: commandCatalogForRuntime(runtime, commands), mode, effort, models: runtime === 'codex' ? codexModels : runtime === 'hermes' ? (Array.isArray(models) && models.length ? models : hostHermesModels) : undefined,
     // model: truthful active-model label — now the SAME `laneModel` the SDK is given, so the
     // chip cannot disagree with the wire. When this lane runs on a custom (non-anthropic)
@@ -2326,7 +2589,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
       : (!provider || provider === 'anthropic')
       ? (laneModel || null)
       : (laneModel || providerNameMap()[provider] || provider),
-    provider: provider || null, spawnedBy: spawnedBy || undefined, spawnDepth: structuralDepth, cascadeRole: cascadeRole === 'conductor' || cascadeRole === 'worker' ? cascadeRole : null, hop: initialHop, sideParent: sideParent || undefined, sideTask: sideTask || undefined, pendingSideContexts: Array.isArray(pendingSideContexts) ? pendingSideContexts.filter(Boolean).slice(-4) : [], pendingWorkerCompletions: Array.isArray(pendingWorkerCompletions) ? pendingWorkerCompletions.filter((item) => item?.workerId && Number(item?.turnRev) > 0).slice(-6) : [], workerCompletionsInFlight: Array.isArray(workerCompletionsInFlight) ? workerCompletionsInFlight.filter((item) => item?.workerId && Number(item?.turnRev) > 0).slice(-6) : [], flowSessionId: flowSessionId || null, flowTaskKey: flowTaskKey || null, cwd: cwd || null, managedWorktree: managedWorktree || null,
+    provider: provider || null, spawnedBy: spawnedBy || undefined, spawnDepth: structuralDepth, cascadeRole: cascadeRole === 'conductor' || cascadeRole === 'worker' ? cascadeRole : null, hop: initialHop, sideParent: sideParent || undefined, sideTask: sideTask || undefined, scheduleRunId: scheduleRunId || null, scheduleDeadlineAt: Number.isFinite(Number(scheduleDeadlineAt)) ? Number(scheduleDeadlineAt) : null, scheduleOutcomeRecorded: scheduleOutcomeRecorded === true, scheduleOutcomePending: restoredScheduleOutcome, scheduleAdmissionLease: scheduleAdmissionLease || null, pendingSideContexts: Array.isArray(pendingSideContexts) ? pendingSideContexts.filter(Boolean).slice(-4) : [], pendingWorkerCompletions: Array.isArray(pendingWorkerCompletions) ? pendingWorkerCompletions.filter((item) => item?.workerId && Number(item?.turnRev) > 0).slice(-6) : [], workerCompletionsInFlight: Array.isArray(workerCompletionsInFlight) ? workerCompletionsInFlight.filter((item) => item?.workerId && Number(item?.turnRev) > 0).slice(-6) : [], flowSessionId: flowSessionId || null, flowTaskKey: flowTaskKey || null, cwd: cwd || null, managedWorktree: managedWorktree || null,
     sliceType: sliceType === 'review' ? 'review' : null,
     flowRole: flowRole || (flowSessionId ? (flowTaskKey ? ((flowReviewTargets?.length || reviewSliceRoots?.length) ? 'reviewer' : 'builder') : 'conductor') : null),
     flowReviewTarget: flowReviewTarget || null,
@@ -2563,6 +2826,10 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
   // with no archive yet; pushLog stamps it from the first appended event.
   entry.archiveOldestSeq = readDurableOldestSeq(room, id)
   sessions.set(id, entry)
+  // Bind and replay an already-chosen durable outcome before any elapsed
+  // restored deadline can arm and overwrite it.
+  if (entry.scheduleOutcomePending) void persistScheduledRunOutcome(entry)
+  else armScheduledRunDeadline(entry)
   // Close an interrupted turn so a restored terminal comes back IDLE-with-history
   // instead of stuck "thinking" (see restoredTurnOpen). Idempotent: the closer is
   // persisted, so a later resume sees a closed turn and no-ops.
@@ -2603,13 +2870,18 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
   // restart. Without this, sessionData omitted it → on restart the resumed session
   // re-launched on the host default (Opus) regardless of the last switch, and the
   // switch looked like it "never changed the model" (Max 2026-07-02). Restored below.
-  const sessionData = () => ({ sessionId: entry.session?.sessionId || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, models: entry.runtime === 'hermes' ? (entry.models || []) : undefined, provider: entry.provider || null, spawnedBy: entry.spawnedBy, spawnDepth: entry.spawnDepth || 0, cascadeRole: entry.cascadeRole || null, hop: entry.hop || 0, sideParent: entry.sideParent, sideTask: entry.sideTask, pendingSideContexts: entry.pendingSideContexts, pendingWorkerCompletions: entry.pendingWorkerCompletions, workerCompletionsInFlight: entry.workerCompletionsInFlight, sliceType: entry.sliceType, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, flowRole: entry.flowRole || null, flowReviewTargets: entry.flowReviewTargets || [], flowReviewSnapshots: entry.flowReviewSnapshots || [], flowReviewRound: entry.flowReviewRound || 0, dispatchBaseSha: entry.dispatchBaseSha || null, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null, carryRecap: entry.pendingRecap || null, receivedTurnCids: [...entry.receivedTurnCids].slice(-1000) })
+  const sessionData = () => ({ sessionId: entry.session?.sessionId || null, runtime: entry.runtime, log: entry.log, commands: entry.commands, mode: entry.mode, effort: entry.effort, model: entry.model || null, models: entry.runtime === 'hermes' ? (entry.models || []) : undefined, provider: entry.provider || null, spawnedBy: entry.spawnedBy, spawnDepth: entry.spawnDepth || 0, cascadeRole: entry.cascadeRole || null, hop: entry.hop || 0, sideParent: entry.sideParent, sideTask: entry.sideTask, scheduleRunId: entry.scheduleRunId || null, scheduleDeadlineAt: entry.scheduleDeadlineAt || null, scheduleOutcomeRecorded: entry.scheduleOutcomeRecorded === true, scheduleAdmissionLease: entry.scheduleAdmissionLease || null, pendingSideContexts: entry.pendingSideContexts, pendingWorkerCompletions: entry.pendingWorkerCompletions, workerCompletionsInFlight: entry.workerCompletionsInFlight, sliceType: entry.sliceType, flowSessionId: entry.flowSessionId, flowTaskKey: entry.flowTaskKey, flowRole: entry.flowRole || null, flowReviewTargets: entry.flowReviewTargets || [], flowReviewSnapshots: entry.flowReviewSnapshots || [], flowReviewRound: entry.flowReviewRound || 0, dispatchBaseSha: entry.dispatchBaseSha || null, cwd: entry.cwd, managedWorktree: entry.managedWorktree, rolePrompt: entry.rolePrompt, flowReviewTarget: entry.flowReviewTarget || null, revertTarget: entry.revertTarget || null, reviewSliceRoots: entry.reviewSliceRoots || [], openedAt: entry.openedAt || null, lastUsage: entry.lastUsage || null, carryRecap: entry.pendingRecap || null, receivedTurnCids: [...entry.receivedTurnCids].slice(-1000) })
   const persist = () => saveSession(room, id, sessionData())
   // Synchronous flush of this session's record. Used on open (so a brand-new session
   // has a file under its id BEFORE its first event — surviving a restart inside the
   // 1.5s saveSession debounce window) and on shutdown (so events since the last
   // debounced write aren't lost). Contract #2: restart resumes, no lost messages.
   entry.flush = () => flushSession(room, id, sessionData())
+  if (entry.scheduleOutcomeRecorded && entry.scheduleAdmissionLease) {
+    void releaseScheduledAdmissionForEntry(entry).then((released) => {
+      if (released) entry.flush?.()
+    })
+  }
   // Main-terminal creation and Ensemble dispatch are different capabilities.
   // A main terminal (human-opened or agent-opened via open_main_terminal) may
   // dispatch workers. A spawned/Side/Flow lane can never elevate itself or a
@@ -3656,6 +3928,15 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
         pushLog(entry, ce)
         bcast('code-event', { term: id, evt: ce })
       }
+      // A busy Codex lane accepts one deferred /compact intent. Claim the
+      // compaction synchronously at the terminal result boundary so a new human
+      // turn cannot slip into the gap, and coalesce every repeated tap into this
+      // one job.
+      if ((evt.kind === 'result' || evt.kind === 'error') && entry.runtime === 'codex' && entry.pendingCodexCompaction) {
+        const request = entry.pendingCodexCompaction
+        entry.pendingCodexCompaction = null
+        startCodexCompaction(entry, request)
+      }
       // ── Slice 3: the turn settled. Two things happen, in this order.
       //   1. Every outstanding permission card on this lane is now dead (the SDK
       //      won't ask again for a turn that ended) — clearAll retracts any
@@ -3773,6 +4054,14 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
         if (mockupDeliveryBoundary) {
           queueMicrotask(() => { mockupDeliveries.flush(id).catch(() => {}) })
         }
+        // A scheduled run has one durable terminal outcome. Deliberately do this
+        // after its terminal boundary is emitted, so a preview created by that turn
+        // is visible before it can count as a deliverable. Plain prose success is
+        // classified as missing_deliverable by the pure runner.
+        if (terminalBoundary && entry.scheduleRunId && (e.kind === 'result' || e.kind === 'error')) {
+          const scheduledResult = entry.scheduleTimedOut ? { ...e, subtype: 'runtime_limit' } : e
+          recordScheduledRunOutcome(entry, scheduledResult, { canceled: !entry.scheduleTimedOut && e.subtype === 'aborted' })
+        }
       }
       // A tool_result carrying an inline base64 image can't ride a broadcast frame
       // (live OR replay). Lift it to Storage FIRST, then emit the URL-only event —
@@ -4009,6 +4298,8 @@ function endStructured(id) {
   if (!id) return
   const s = sessions.get(id)
   if (s) {
+    recordScheduledRunOutcome(s, { subtype: 'canceled' }, { canceled: true })
+    clearScheduledRunDeadline(s)
     s.imageQueue?.close()
     mockupDeliveries.clear(id)
     drainPending(s)
@@ -4678,6 +4969,7 @@ channel
     }
     if (/^\/clear\s*$/.test(text)) {
       s.pendingRecap = null   // /clear means forget context — drop any un-fired carry recap
+      s.pendingCodexCompaction = null // explicit clear supersedes a deferred compact
       if (s.runtime === 'codex' || s.runtime === 'hermes') s.session.clearContext?.()
       else s.session.sendTurn(text)
       // The seq reset is load-bearing on BOTH ends: the client's clear handler sets
@@ -4698,61 +4990,16 @@ channel
     // No persisted ctl line — the live indicator + the CompactionCard are the record.
     if (/^\/compact\s*$/.test(text)) {
       if (s.runtime === 'codex') {
+        // One lifecycle owns every distinct press. During an ordinary turn the
+        // first request is queued and truthfully runs at its result boundary;
+        // later taps, including taps during native compaction, coalesce silently.
+        if (s.codexCompactionPromise || s.pendingCodexCompaction) return
         if (s.session.turnActive) {
-          ctlLine('Compact after this turn ends.', { tone: 'caution' })
-          return
-        }
-        const recap = buildRecapFromLog(s.log, RECAP_CAP, { reason: 'compact' })
-        if (!recap) {
-          ctlLine('nothing to compact — context unchanged')
-          return
-        }
-        const preTokens = s.lastUsage?.ctx?.used || null
-        bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'start', ts: Date.now() } })
-        let nativeCompacted = false
-        try {
-          nativeCompacted = await s.session.compactContext?.()
-        } catch {
-          // The bounded recap below is the safe fallback for a native transport
-          // failure. The roster edge is still settled in finally.
-        } finally {
-          // Native compaction emits usage while compactActive=true, so onEvent
-          // legitimately announces a busy edge. It has no ordinary result event;
-          // close that borrowed edge here after compactContext's finally clears
-          // compactActive, or "Compacting…" degrades into stale "Thinking…".
-          // A browser turn may have arrived while compactContext awaited App
-          // Server readiness. Never let control cleanup settle that ordinary
-          // turn's busy edge; the normal result boundary owns it.
-          if (!s.session.turnActive && settleLaneControl(s)) announce()
-        }
-        if (nativeCompacted) {
-          const ce = { kind: 'compaction', trigger: 'manual', preTokens, by: payload.by, native: true }
-          pushLog(s, ce)
-          bcast('code-event', { term: payload.term, evt: ce })
-          bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
-          s.flush?.()
-          return
-        }
-        if (s.session.clearContext?.() === false) {
-          bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
-          ctlLine('Codex context compaction unavailable right now')
+          s.pendingCodexCompaction = { by: payload.by, cid: payload.cid }
+          ctlLine('Compaction queued for after this turn.', { tone: 'caution' })
           return
         }
-        s.pendingRecap = recap
-        const ce = { kind: 'compaction', trigger: 'manual', preTokens, by: payload.by }
-        pushLog(s, ce)
-        bcast('code-event', { term: payload.term, evt: ce })
-        // The new native thread has only the bounded recap queued for the next
-        // human turn. Reset the visible meter to that conservative text estimate.
-        if (s.lastUsage?.ctx?.max) {
-          const used = Math.ceil(recap.length / 4)
-          const max = s.lastUsage.ctx.max
-          const usage = { kind: 'usage', ctx: { ...s.lastUsage.ctx, used, max, pct: Math.min(100, Math.round((used / max) * 100)), over: used > max } }
-          s.lastUsage = usage
-          bcast('code-event', { term: payload.term, evt: usage })
-        }
-        bcast('code-event', { term: payload.term, evt: { kind: 'compact', status: 'done', ts: Date.now() } })
-        s.flush?.()
+        startCodexCompaction(s, { by: payload.by, cid: payload.cid })
         return
       }
       s.compacting = true
@@ -4989,7 +5236,7 @@ channel
             // FL-M6 — restore the flow context (id/role/cwd) so an in-flight flow survives a
             // bridge restart: the conductor keeps its subagent-block + plan interception, and
             // lanes keep their worktree cwd + the ability to mark done.
-            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, models: rec.models, effort: rec.effort, provider: rec.runtime === 'claude' ? rec.provider || undefined : undefined, resume: resumable ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, spawnDepth: rec.spawnDepth, cascadeRole: rec.cascadeRole, hop: rec.hop, sideParent: rec.sideParent, sideTask: rec.sideTask, pendingSideContexts: rec.pendingSideContexts, pendingWorkerCompletions: rec.pendingWorkerCompletions, workerCompletionsInFlight: rec.workerCompletionsInFlight, sliceType: rec.sliceType, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, flowRole: rec.flowRole, flowReviewTarget: rec.flowReviewTarget, flowReviewTargets: rec.flowReviewTargets, flowReviewSnapshots: rec.flowReviewSnapshots, flowReviewRound: rec.flowReviewRound, dispatchBaseSha: rec.dispatchBaseSha, revertTarget: rec.revertTarget, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, receivedTurnCids: rec.receivedTurnCids, carryRecap: wasInterrupted ? recoveryRecap : rec.carryRecap,
+            openStructured({ id: rec.id, runtime: rec.runtime || 'claude', model: rec.model || undefined, models: rec.models, effort: rec.effort, provider: rec.runtime === 'claude' ? rec.provider || undefined : undefined, resume: resumable ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode, spawnedBy: rec.spawnedBy, spawnDepth: rec.spawnDepth, cascadeRole: rec.cascadeRole, hop: rec.hop, sideParent: rec.sideParent, sideTask: rec.sideTask, scheduleRunId: rec.scheduleRunId, scheduleDeadlineAt: rec.scheduleDeadlineAt, scheduleOutcomeRecorded: rec.scheduleOutcomeRecorded, scheduleAdmissionLease: rec.scheduleAdmissionLease, pendingSideContexts: rec.pendingSideContexts, pendingWorkerCompletions: rec.pendingWorkerCompletions, workerCompletionsInFlight: rec.workerCompletionsInFlight, sliceType: rec.sliceType, flowSessionId: rec.flowSessionId, flowTaskKey: rec.flowTaskKey, flowRole: rec.flowRole, flowReviewTarget: rec.flowReviewTarget, flowReviewTargets: rec.flowReviewTargets, flowReviewSnapshots: rec.flowReviewSnapshots, flowReviewRound: rec.flowReviewRound, dispatchBaseSha: rec.dispatchBaseSha, revertTarget: rec.revertTarget, cwd: rec.cwd, managedWorktree: rec.managedWorktree, rolePrompt: rec.rolePrompt, reviewSliceRoots: rec.reviewSliceRoots, openedAt: rec.openedAt, lastUsage: rec.lastUsage, receivedTurnCids: rec.receivedTurnCids, carryRecap: wasInterrupted ? recoveryRecap : rec.carryRecap,
               // Lazy-boot restored terminals that were IDLE + not part of a flow: their transcript
               // shows immediately; the query boots on first turn. Mid-turn + flow terminals boot now
               // (mid-turn needs auto-resume; flow needs its lane live).
@@ -5466,6 +5713,83 @@ designChannel
     if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT' || status === 'CLOSED') process.stderr.write(`\n  ⚠ design realtime ${status} (tpdesign:${room}).\n`)
   })
 
+// Owner-bridge-only, local polling for V1 unattended schedules. The database claim
+// is the cross-process fence; this guard only prevents overlapping HTTP ticks in one
+// bridge. A due run always becomes an ordinary top-level terminal with run provenance.
+let scheduledRunPollBusy = false
+const scheduledProviderAvailable = (schedule) => {
+  const runtime = schedule?.runtime
+  const provider = schedule?.provider_id || 'anthropic'
+  if (runtime === 'claude') {
+    if (!listProviders().some((item) => item.id === provider)) return false
+    return provider === 'anthropic' || !schedule?.model || providerModel(provider) === schedule.model
+  }
+  if (schedule?.provider_id) return false // V1 never silently maps non-Claude providers.
+  if (runtime === 'codex') return !schedule?.model || modelCatalogValues(readCodexModels()).has(schedule.model)
+  if (runtime === 'hermes') return !schedule?.model || hostHermesModels.some((item) => (item?.id || item?.model) === schedule.model)
+  return false
+}
+const pollScheduledRuns = async () => {
+  if (scheduledRunPollBusy || shuttingDown || !codeAuthToken || !myServeUid || !ACCOUNT_BRIDGE_ID || !Number.isSafeInteger(ACCOUNT_BRIDGE_FENCING) || ACCOUNT_BRIDGE_FENCING < 1) return
+  scheduledRunPollBusy = true
+  try {
+    // Finishing a previously-opened occurrence is cleanup, not a new scheduled
+    // execution. Recover it even when the owner has since disabled new runs.
+    const outcomesReconciled = await recoverPendingScheduledRunOutcomes()
+    // expire_code_scheduled_runs is intentionally downstream of host-outbox
+    // reconciliation. Otherwise a restart can expire a delivered/decision run
+    // while its idempotent finish is still waiting for a database ack.
+    if (!outcomesReconciled) return
+    if (!scheduledRunsEnabled()) return
+    const result = await pollDueScheduledRuns({
+      enabled: true, supabaseUrl: SUPABASE_URL, anonKey: SUPABASE_ANON, token: codeAuthToken, roomCode: room, bridgeId: ACCOUNT_BRIDGE_ID, bridgeFencing: ACCOUNT_BRIDGE_FENCING, ownerId: myServeUid,
+      providerAvailable: scheduledProviderAvailable,
+      admitRun: async ({ runId, terminalId, deadlineAt }) => {
+        const localAdmission = scheduledRunSpawnAdmission({
+          // The rolling burst authority is the host-wide ledger below. This
+          // local gate retains the room process kill-switch and live-lane cap.
+          spawnTimes: [],
+          totalLive: sessions.size + terms.size,
+          disabled: process.env.TP_SPAWN_OFF === '1',
+        })
+        if (!localAdmission.ok) return localAdmission
+        return acquireScheduledRunAdmission({ runId, terminalId, deadlineAt })
+      },
+      releaseRun: (lease) => releaseScheduledRunAdmission(lease),
+      openTerminal: async ({ schedule, run, terminalId: id, admission }) => {
+        // The durable occurrence is opened before this local terminal. Never reuse
+        // an existing session or worker lane for unattended work.
+        const leaseExpiry = Date.parse(run.lease_expires_at)
+        const scheduleDeadlineAt = Number.isFinite(leaseExpiry) ? leaseExpiry - 60_000 : NaN
+        if (!Number.isFinite(scheduleDeadlineAt) || scheduleDeadlineAt <= Date.now()) return null
+        const entry = openStructured({ id, runtime: schedule.runtime, provider: schedule.provider_id || undefined, model: schedule.model || undefined, mode: 'default', scheduleRunId: run.id, scheduleDeadlineAt, scheduleAdmissionLease: admission })
+        if (!entry) return null
+        termNames[id] = String(schedule.title || 'Scheduled run').slice(0, 80)
+        saveNames(room, termNames)
+        const accepted = dispatchStructuredTurn(entry, String(schedule.prompt || ''), {
+          visibleEvent: { kind: 'you', text: String(schedule.prompt || ''), by: 'Scheduled run' },
+          rejectionMessage: 'The scheduled run could not start; no hidden fallback was used.',
+        })
+        if (!accepted?.accepted) {
+          // pollDueScheduledRuns owns the explicit terminal_open_failed outcome.
+          // Detach this process-local entry before closing so endStructured cannot
+          // race it with a synthetic canceled outcome.
+          entry.scheduleRunId = null
+          clearScheduledRunDeadline(entry)
+          endStructured(id)
+          return null
+        }
+        armScheduledRunDeadline(entry)
+        entry.flush?.(); announce()
+        return id
+      },
+    })
+    if (!result.ok && process.env.TP_DEBUG && result.code !== 'runner_read_failed') process.stderr.write(`\n  ◇ scheduled-run poll: ${result.code}\n`)
+  } finally { scheduledRunPollBusy = false }
+}
+void pollScheduledRuns()
+setInterval(() => { void pollScheduledRuns() }, 15_000).unref()
+
 // Watchdog — restart only for a Realtime-only wedge. A total network/Supabase
 // outage cannot be repaired by killing the room process; doing so destroys local
 // agent runtimes and leaves the supervisor unable to rediscover the room until HTTP