elanous 0.2.25 → 0.2.28

package/src/session-runtime/index.ts

@@ -4,6 +4,7 @@ import { getUserConfig } from '../user-config.js';
 import { resolve } from 'node:path';
 import type { ModelFamily } from '../models/prompts.js';
 import type { InputSourceKind, InputSourceRef } from '../input/input-source-kind.js';
+import type { ControlTurnIntent, SubmitTurnIntent } from '../input/input-intent.js';
 import { getSessionCwd } from '../session/working-dir.js';
 import {
   armQuickControlOnce,
@@ -22,6 +23,7 @@ import {
 import type { LLMMessage, LLMToolSpec } from '../llm.js';
 import type { LLMToolDef } from '../plugins/core/types.js';
 import type { ToolRunResult, ToolRuntime } from '../tool-runtime/types.js';
+import { blockWriteToolSearchHydration, type ToolSearchRunResult } from '../tool-runtime/tool-search-runtime.js';
 import { findNativeTool, isNativeToolModelExposed } from '../native-tool-catalog.js';
 import { hasAstGrep } from '../skills/tools/ast-grep.js';
 import { buildOmniSearchTool, omniSearchAvailable } from '../skills/tools/omni-search.js';
@@ -1731,6 +1733,8 @@ const ESSENTIAL_NATIVE_RULE_IDS = [
   'agent', 'agent-output', 'agent-reply', 'agent-stop', 'agent-list', 'self-implement', 'self-orchestrate', 'dev-harness',
 ] as const;
 const ESSENTIAL_HOST_FAMILY_IDS = ['self-ops', 'release-read'] as const;
+// Keep this TUI essential addition out of the shared control/agent self-ops family.
+const ESSENTIAL_HOST_EXTRA_NAMES = ['logs_query'] as const;
 const ESSENTIAL_RUNTIME_FAMILY_IDS = ['bash', 'run-shell', 'pty-shell', 'run-tests', 'elanous_skills_list', 'skill_exec', 'code-grounding'] as const;
 const ESSENTIAL_OPTIONAL_TOOL_NAMES = [
   'GetDashboardState',
@@ -1764,7 +1768,11 @@ function buildEssentialSessionRuntimeToolSpecs(opts: {
         .filter((tool): tool is LLMToolDef => !!tool)
         .map(toSpec)
       : [];
-  });
+  }).concat(ESSENTIAL_HOST_EXTRA_NAMES
+    .filter(name => isToolAvailable(name, opts.toolAvailability))
+    .map(name => hostByName.get(name))
+    .filter((tool): tool is LLMToolDef => !!tool)
+    .map(toSpec));
   const runtimeById = new Map(opts.runtimeTools.map(tool => [tool.id, tool] as const));
   const runtimeSpecs = ESSENTIAL_RUNTIME_FAMILY_IDS.flatMap(id => {
     const rule = RUNTIME_TOOL_FAMILY_RULE_MAP.get(id);
@@ -1833,12 +1841,23 @@ export function buildSessionRuntimeToolSpecs(opts: {
   // toolset (incident 2026-05-04 — Opus replied "no file tools in this
   // session" while Bash was actually exposed at position 7+).
   const finalSpecs: LLMToolSpec[] = opts.rich === false
-    ? buildEssentialSessionRuntimeToolSpecs({
-        hostTools: opts.hostTools,
-        runtimeTools: opts.runtimeTools ?? [],
-        optionalTools: opts.optionalTools ?? [],
-        toolAvailability: opts.toolAvailability,
-      })
+    ? (() => {
+        const essentialSpecs = buildEssentialSessionRuntimeToolSpecs({
+          hostTools: opts.hostTools,
+          runtimeTools: opts.runtimeTools ?? [],
+          optionalTools: opts.optionalTools ?? [],
+          toolAvailability: opts.toolAvailability,
+        });
+        if (!hasDevHarnessIntent(opts.userText)) return essentialSpecs;
+        const droppedNames = new Set(['Edit', 'Write']);
+        const filteredSpecs = essentialSpecs.filter(spec => !droppedNames.has(spec.name));
+        if (filteredSpecs.length !== essentialSpecs.length) {
+          debug.log('session-runtime.tools', 'harness-phrase-write-tools-dropped', {
+            dropped: ['Edit', 'Write'],
+          });
+        }
+        return filteredSpecs;
+      })()
     : [
         ...dynamicNativeTools,
         ...hostSpecs,
@@ -2084,6 +2103,10 @@ export async function dispatchSessionRuntimeTool(
   args: Record<string, unknown>,
   deps: SessionRuntimeDispatchDeps,
 ): Promise<unknown> {
+  const finishRuntimeResult = (result: unknown): unknown =>
+    name === 'ToolSearch' && isDevHarnessIntent(deps.userText ?? '')
+      ? blockWriteToolSearchHydration(result as ToolSearchRunResult)
+      : result;
   // Fix W-bis (2026-04-25): codex family always enables scoped-analysis
   // mode regardless of userText vocabulary. Rationale (see docs/RESEARCH-
   // codex-reread-pathology-2refs-2026-04-25.md): codex's search-heavy
@@ -2178,8 +2201,9 @@ export async function dispatchSessionRuntimeTool(
   const nativeRuntime = nativeRule?.preferRuntime ? deps.getToolRuntime(name) : undefined;
   if (nativeRuntime) {
     const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
-    rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
-    return result;
+    const safeResult = finishRuntimeResult(result);
+    rememberCandidateListingResult(name, normalizedArgs, safeResult, scopedAnalysis, deps.searchPlannerState);
+    return safeResult;
   }
   if (nativeRule?.dispatch) {
     let result: unknown;
@@ -2213,8 +2237,9 @@ export async function dispatchSessionRuntimeTool(
     const isPtyTool = name.startsWith('PtyShell') || name.startsWith('pty_shell');
     if (!isPtyTool || deps.ptyDashboardOn) {
       const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
-      rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
-      return result;
+      const safeResult = finishRuntimeResult(result);
+      rememberCandidateListingResult(name, normalizedArgs, safeResult, scopedAnalysis, deps.searchPlannerState);
+      return safeResult;
     }
   }
 
@@ -2699,6 +2724,25 @@ function hasDevHarnessIntent(text: string): boolean {
   return hasAny(text, DEV_HARNESS_INTENT_TERMS);
 }
 
+export function isDevHarnessIntent(text: string): boolean {
+  return hasDevHarnessIntent(text);
+}
+
+/** The dashboard calls this immediately after submitIntent resolution. A
+ * fixed plain turn becomes the same control turn used by `/harness ask`, so
+ * the model dispatch branch is never reached for that turn. */
+export function routeDevHarnessSubmitIntent(
+  intent: SubmitTurnIntent | ControlTurnIntent,
+): SubmitTurnIntent | ControlTurnIntent {
+  if (intent.kind !== 'submit-turn' || intent.route !== 'plain' || !isDevHarnessIntent(intent.text)) return intent;
+  return {
+    kind: 'control-turn',
+    source: intent.source,
+    command: 'slash-command',
+    commandText: `/harness ask ${intent.text}`,
+  };
+}
+
 export function shouldExposeDevHarnessSessionTool(text: string): boolean {
   return isDevHarnessModelSurfaceEnabled() && hasDevHarnessIntent(text);
 }

package/src/skills/tools/persistent-grounding.ts

@@ -212,6 +212,26 @@ function groundingMessages(goal: string, terms: readonly string[]): LLMMessage[]
   }];
 }
 
+function unreadEvidencePaths(evidence: string, readFiles: ReadonlySet<string>): string[] {
+  return Array.from(new Set(evidence.split(/\r?\n/)
+    .flatMap(repositoryRelativeCodePaths)
+    .filter((path) => isCodeRootPath(path) && !readFiles.has(path)))).slice(0, 8);
+}
+
+function rejectedEvidenceFeedback(evidence: string, readFiles: ReadonlySet<string>): LLMMessage {
+  const unread = unreadEvidencePaths(evidence, readFiles);
+  const read = Array.from(readFiles).slice(0, 8);
+  return {
+    role: 'user',
+    content: [
+      'Your completion evidence was rejected because it cited a repository path that Read did not verify.',
+      `Unverified paths: ${unread.length ? unread.join(', ') : '(none in allowed code roots)'}`,
+      `Paths actually Read: ${read.length ? read.join(', ') : '(none)'}`,
+      'Try once more. Read each relevant unverified path before citing it, or remove it from the evidence. Cite only repository-relative code paths that this grounding run actually Read, each with a concrete reason. If no path is relevant, do not invent evidence.',
+    ].join('\n'),
+  };
+}
+
 /** Bounded, shared, read-only grounding loop. Failure or no candidates returns null. */
 export async function groundPersistently(goal: string, cwd: string, deps: PersistentGroundingDeps = {}): Promise<PersistentGroundingResult | null> {
   const startedAt = performance.now();
@@ -250,20 +270,53 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
       },
     };
     const options: GoalLoopOptions = { maxIterations, objective: `Persistent repository grounding: ${goal.slice(0, 200)}` };
-    const result = await loop(ctx, options);
-    const verified = result.goalComplete && result.stopReason === 'goal_complete'
+    const first = await loop(ctx, options);
+    const firstVerified = first.goalComplete && first.stopReason === 'goal_complete'
       ? verifiedEvidenceFromCompletion(completionEvidence, readFiles)
       : {
         files: [],
         evidence: [],
         rejection: { noPath: 0, outsideRoot: 0, notRead: 0, noMeaningfulText: 0, samples: [] },
       };
+    let result = first;
+    let verified = firstVerified;
+    let feedbackRetry = false;
+    let retryIterations = 0;
+    if (firstVerified.rejection.notRead > 0) {
+      feedbackRetry = true;
+      const feedback = rejectedEvidenceFeedback(completionEvidence, readFiles);
+      completionEvidence = '';
+      try {
+        const retry = await loop({ ...ctx, sessionId: `${sessionId}-evidence-retry`, messages: [...ctx.messages, feedback] },
+          { ...options, maxIterations: 2 });
+        retryIterations = retry.iterations;
+        const retryVerified = retry.goalComplete && retry.stopReason === 'goal_complete'
+          ? verifiedEvidenceFromCompletion(completionEvidence, readFiles)
+          : null;
+        if (retryVerified) {
+          verified = {
+            files: Array.from(new Set([...firstVerified.files, ...retryVerified.files])),
+            evidence: Array.from(new Set([...firstVerified.evidence, ...retryVerified.evidence])),
+            rejection: retryVerified.rejection,
+          };
+          result = retry;
+        }
+      } catch (error) {
+        try {
+          debug.log('grounding.persistent', 'evidence-retry-failed', { sessionId,
+            reason: error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200) }, { level: 'warn' });
+        } catch {
+          // A failed retry and its telemetry cannot erase evidence already verified by Read.
+        }
+      }
+    }
+    const totalIterations = first.iterations + retryIterations;
     try {
       debug.log('grounding.persistent', 'finished', {
         sessionId,
         maxIterations,
         durationMs: durationMs(),
-      iterations: result.iterations,
+      iterations: totalIterations,
       stopReason: result.stopReason,
       // ⛔ 「끝났다」가 두 뜻이다 — ⓐ 스스로 목표를 끝냈다 ⓑ 턴이 «그냥» 끝났다.
       //   📏 2026-08-11 72차 전수(400건): 후보 0인 finished 가 5건이고 ***다섯 다 end_turn*** 이었다.
@@ -273,6 +326,8 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
       candidateCount: verified.files.length,
       evidenceCount: verified.evidence.length,
       evidenceRejection: verified.rejection,
+      feedbackRetry,
+      ...(feedbackRetry ? { firstEvidenceRejection: firstVerified.rejection } : {}),
         toolCalls,
       });
     } catch {
@@ -281,7 +336,7 @@ export async function groundPersistently(goal: string, cwd: string, deps: Persis
     return {
       files: verified.files,
       evidence: verified.evidence,
-      iterations: result.iterations,
+      iterations: totalIterations,
       stopReason: result.stopReason,
     };
   } catch (error) {

package/src/skills/tools/shell.ts

@@ -31,9 +31,13 @@ import {
   runShell as runnerDispatch,
   getShellRunnerDeps,
 } from '../../shell-runner/dispatch.js';
-import type { ShellResult as RunnerResult } from '../../shell-runner/types.js';
+import type { ShellHandle, ShellResult as RunnerResult } from '../../shell-runner/types.js';
 import { debug } from '../../debug/log.js';
 import { getSessionCwd } from '../../session/working-dir.js';
+import {
+  globalTaskNotificationQueue,
+  type TaskNotificationQueue,
+} from '../../agent/task-notification.js';
 
 /** LLMToolSpec — the shape surfaced to the model. Kept narrow so
  *  accidental misuse is hard: no env override, no cwd outside the
@@ -178,6 +182,62 @@ function logShellDispatch(event: string, data: Record<string, unknown>): void {
   debug.log('shell.dispatch', event, data);
 }
 
+// ── bg completion → turn notification queue (TUI-BG-SHELL) ───────────
+// When a bg-mode shell handle settles, its result is no longer awaited
+// by anyone — the spawn already returned the `outcome=started` stub.
+// To surface the eventual result we enqueue one task-notification into
+// the existing turn notification queue (injected at turn-start by
+// chat/skill-runner). One notice per handle; opening an idle turn from
+// the wake signal is deliberately NOT wired here (TUI-EVENT-TURN-QUEUE).
+
+export interface ShellCompletionNoticeInput {
+  handle: ShellHandle;
+  ok: boolean;
+  exitCode: number | null;
+  durationMs: number;
+  /** Set when ok === false — the runner's failure reason. */
+  errorMessage?: string;
+  /** Caller-supplied free-form label (RunShell's `description` arg). */
+  label?: string;
+}
+
+/** Per-handle dedup guard — module-local, keyed by the handle OBJECT.
+ *  A registry replacement may mint a NEW handle that reuses an id; the
+ *  shell layer must not swallow that fresh completion as a duplicate
+ *  settle (an id-keyed record here would). */
+const notifiedHandles = new WeakSet<ShellHandle>();
+let nextShellCompletionNoticeId = 0;
+
+/** Enqueue one bg shell-handle completion notice. Returns true when this
+ *  handle had not notified before (the notice was handed to `queue`),
+ *  false on a duplicate settle of the same handle. The queue's own
+ *  The shared queue deduplicates by taskId even after drain, so each
+ *  completed handle gets its own notification id. The original handle id
+ *  remains in the output for ShellPoll and human follow-up.
+ *  `queue` defaults to the global turn notification queue; injectable
+ *  so tests can isolate. */
+export function enqueueShellCompletionNotice(
+  input: ShellCompletionNoticeInput,
+  queue: TaskNotificationQueue = globalTaskNotificationQueue,
+): boolean {
+  if (notifiedHandles.has(input.handle)) return false;
+  notifiedHandles.add(input.handle);
+  const header = `RunShell bg handle=${input.handle.id} ${input.ok ? 'completed' : 'failed'}`;
+  const output = `${header}${input.ok || input.exitCode !== null ? ` exitCode=${input.exitCode ?? 'null'}` : ''} elapsed=${input.durationMs}ms${input.errorMessage ? ` error=${input.errorMessage}` : ''}`;
+  queue.enqueue({
+    taskId: `shell:${input.handle.id}:${++nextShellCompletionNoticeId}`,
+    agentName: 'RunShell',
+    ...(input.label ? { label: input.label } : {}),
+    state: input.ok ? 'done' : 'error',
+    output,
+    truncated: false,
+    ...(input.errorMessage ? { errorMessage: input.errorMessage } : {}),
+    durationMs: input.durationMs,
+    finishedAt: Date.now(),
+  });
+  return true;
+}
+
 export async function dispatchRunShell(
   rawArgs: Record<string, unknown>,
   opts: { signal?: AbortSignal } = {},
@@ -269,6 +329,16 @@ async function dispatchViaRunner(args: {
           exitCode: result.exitCode ?? null,
           durationMs: result.durationMs,
         });
+        const ok = result.outcome === 'exit' && result.exitCode === 0;
+        enqueueShellCompletionNotice({
+          handle,
+          ok,
+          exitCode: result.exitCode ?? null,
+          durationMs: result.durationMs,
+          ...(!ok ? { errorMessage: result.exitCode !== undefined
+            ? `exitCode=${result.exitCode}` : `outcome=${result.outcome}` } : {}),
+          ...(args.description !== undefined ? { label: args.description } : {}),
+        });
       },
       (err: unknown) => {
         debug.log('skill-tool.shell', 'bg-finished', {
@@ -277,6 +347,14 @@ async function dispatchViaRunner(args: {
           durationMs: Date.now() - bgStartedAt,
           error: err instanceof Error ? err.message : String(err),
         });
+        enqueueShellCompletionNotice({
+          handle,
+          ok: false,
+          exitCode: null,
+          durationMs: Date.now() - bgStartedAt,
+          errorMessage: err instanceof Error ? err.message : String(err),
+          ...(args.description !== undefined ? { label: args.description } : {}),
+        });
       },
     );
     return {

package/src/steward/rejudge-tick.ts

@@ -19,6 +19,7 @@ import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { spawnElanous } from '../instance/spawn-elanous.js';
 import { getUserConfig } from '../user-config.js';
+import { resyncPendingPath } from './resync-tick.js';
 
 export const REJUDGE_TICK_EVENT = 'rejudge-tick';
 export const REJUDGE_DEFAULT_MAX_LOAD = 60;
@@ -49,6 +50,7 @@ export interface RejudgeTickDeps {
   config?: () => { rejudgeEveryMinutes?: number; rejudgeMaxLoad?: number } | undefined;
   load?: () => number;
   stampPath?: string;
+  pendingPath?: string;
   run?: () => Promise<RejudgeRun>;
   log?: (event: string, data: Record<string, unknown>) => void;
 }
@@ -110,7 +112,9 @@ export async function rejudgeTick(deps: RejudgeTickDeps = {}): Promise<RejudgeTi
     const now = (deps.now ?? (() => new Date()))();
     const stampPath = deps.stampPath ?? defaultStampPath();
     const lastStartedAt = readStamp(stampPath);
-    if (lastStartedAt && now.getTime() - Date.parse(lastStartedAt) < everyMinutes * 60_000 - REJUDGE_JITTER_MS) {
+    const pendingAt = readPending(deps.pendingPath ?? resyncPendingPath());
+    const savedSinceLastRun = pendingAt !== null && (!lastStartedAt || Date.parse(pendingAt) > Date.parse(lastStartedAt));
+    if (!savedSinceLastRun && lastStartedAt && now.getTime() - Date.parse(lastStartedAt) < everyMinutes * 60_000 - REJUDGE_JITTER_MS) {
       return emit({ decision: 'not-due', everyMinutes, lastStartedAt });
     }
     const maxLoad = positive(cfg?.rejudgeMaxLoad) ?? REJUDGE_DEFAULT_MAX_LOAD;
@@ -133,6 +137,13 @@ export async function rejudgeTick(deps: RejudgeTickDeps = {}): Promise<RejudgeTi
   }
 }
 
+function readPending(path: string): string | null {
+  try {
+    const value = (JSON.parse(readFileSync(path, 'utf8')) as { savedAt?: unknown }).savedAt;
+    return typeof value === 'string' && Number.isFinite(Date.parse(value)) ? value : null;
+  } catch { return null; }
+}
+
 if (import.meta.main) {
   try { await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('steward'); }
   catch (error) { console.error(`steward rejudge: log sink registration failed — ${error instanceof Error ? error.message : String(error)}`); }

package/src/steward/release-day.ts

@@ -0,0 +1,158 @@
+/** Release-day shadow: observe the scheduled phase without performing its action. */
+import { chmodSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Database } from 'bun:sqlite';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { listSchedules, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+
+export type ReleaseDayPhase = 'gate-mode' | 'carry-p0' | 'cut-run' | 'green-back' | 'none' | 'unmeasured';
+export interface ReleaseDayDecision {
+  version: string;
+  phase: ReleaseDayPhase;
+  dueAt: string | null;
+  scheduleUpdatedAt: string;
+  reason?: string;
+}
+
+/** The release record, rather than publishAt (a planned time), opens green-back. */
+export function decideReleaseDayPhase(schedule: ReleaseSchedule, now: Date, publishedAt: string | null): ReleaseDayDecision {
+  const cut = Date.parse(schedule.cutAt);
+  const land = schedule.landBy ? Date.parse(schedule.landBy) : cut;
+  const gate = cut - 30 * 60_000;
+  const time = now.getTime();
+  let phase: ReleaseDayPhase = 'none';
+  let dueAt: string | null = null;
+  if (publishedAt && time >= Date.parse(publishedAt)) {
+    phase = 'green-back'; dueAt = publishedAt;
+  } else if (time >= cut) {
+    phase = 'cut-run'; dueAt = schedule.cutAt;
+  } else if (time >= land) {
+    phase = 'carry-p0'; dueAt = schedule.landBy;
+  } else if (time >= gate) {
+    phase = 'gate-mode'; dueAt = new Date(gate).toISOString();
+  }
+  return { version: schedule.version, phase, dueAt, scheduleUpdatedAt: schedule.updatedAt };
+}
+
+export type PublicationProbe = { kind: 'published'; at: string } | { kind: 'unpublished' } | { kind: 'unmeasured'; reason: string };
+
+function actualPublicationProbe(version: string, root: string): PublicationProbe {
+  const path = join(root, 'release', version, 'release.json');
+  let raw: string;
+  try { raw = readFileSync(path, 'utf8'); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return { kind: 'unpublished' };
+    return { kind: 'unmeasured', reason: 'release-record-read-failed' };
+  }
+  try {
+    const record = JSON.parse(raw) as { version?: unknown; publishedAt?: unknown };
+    if (record.version !== version) return { kind: 'unmeasured', reason: 'release-record-version-mismatch' };
+    if (record.publishedAt == null) return { kind: 'unmeasured', reason: 'release-record-published-at-missing' };
+    if (typeof record.publishedAt !== 'string' || !Number.isFinite(Date.parse(record.publishedAt)))
+      return { kind: 'unmeasured', reason: 'release-record-published-at-invalid' };
+    return { kind: 'published', at: record.publishedAt };
+  } catch { return { kind: 'unmeasured', reason: 'release-record-json-failed' }; }
+}
+
+export interface ReleaseDayScheduleState { publication: PublicationProbe; greenObserved: boolean }
+
+/** A late release and the next gate can both be due; return both instead of starving either. */
+export function selectReleaseDaySchedules(
+  schedules: ReleaseSchedule[], now: Date, state: (version: string) => ReleaseDayScheduleState,
+): ReleaseSchedule[] {
+  const ordered = schedules.filter(s => Number.isFinite(Date.parse(s.cutAt))).sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt));
+  const time = now.getTime();
+  const dueFuture = ordered.filter(s => {
+    const cut = Date.parse(s.cutAt);
+    const firstDue = Math.min(cut - 30 * 60_000, s.landBy ? Date.parse(s.landBy) : cut);
+    return time < cut && time >= firstDue;
+  });
+  const past = ordered.filter(s => Date.parse(s.cutAt) <= time);
+  const unpublished = past.filter(s => state(s.version).publication.kind === 'unpublished');
+  const unmeasured = past.filter(s => state(s.version).publication.kind === 'unmeasured');
+  const pendingGreen = past.filter(s => {
+    const status = state(s.version);
+    return status.publication.kind === 'published' && !status.greenObserved;
+  });
+  const due = [...dueFuture, ...unpublished, ...unmeasured, ...pendingGreen];
+  if (due.length) return [...new Map(due.map(s => [s.version, s])).values()];
+  const upcoming = ordered.find(s => Date.parse(s.cutAt) > time);
+  return upcoming && Date.parse(upcoming.cutAt) - time <= 24 * 60 * 60_000 ? [upcoming] : [];
+}
+
+export interface ReleaseDayShadowDeps {
+  now?: () => Date;
+  releaseRoot?: string;
+  stateRoot?: string;
+  schedules?: () => ReleaseSchedule[];
+  publishedAt?: (version: string, root: string) => string | null;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export interface ReleaseDayShadowResult extends ReleaseDayDecision { recorded: boolean }
+
+export function runReleaseDayShadow(deps: ReleaseDayShadowDeps = {}): ReleaseDayShadowResult[] {
+  const now = (deps.now ?? (() => new Date()))();
+  // The graph child's stamped universe also owns its release schedule under --test.
+  const releaseRoot = deps.releaseRoot ?? effectiveInstanceRoot();
+  const schedules = (deps.schedules ?? (() => listSchedules(releaseRoot)))();
+  const log = deps.log ?? ((event: string, data: Record<string, unknown>) => debug.log('steward.release-day', event, data));
+  if (!schedules.length) { log('decision', { phase: 'none', reason: 'no-release-schedule', at: now.toISOString(), recorded: false, mode: 'shadow' }); return []; }
+  const dir = join(deps.stateRoot ?? effectiveInstanceRoot(), 'steward');
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, 'release-day-shadow.sqlite');
+  const db = new Database(path, { create: true, strict: true });
+  try {
+    chmodSync(path, 0o600);
+    db.exec('PRAGMA busy_timeout = 10000');
+    db.exec('CREATE TABLE IF NOT EXISTS phase_observations (version TEXT NOT NULL, phase TEXT NOT NULL, due_at TEXT NOT NULL, observed_at TEXT NOT NULL, schedule_updated_at TEXT NOT NULL, PRIMARY KEY (version, phase))');
+    const states = new Map<string, ReleaseDayScheduleState>();
+    for (const schedule of schedules) {
+      const observed = db.query('SELECT phase FROM phase_observations WHERE version = ?').all(schedule.version) as Array<{ phase: string }>;
+      const injected = deps.publishedAt?.(schedule.version, releaseRoot);
+      states.set(schedule.version, {
+        publication: deps.publishedAt
+          ? injected == null ? { kind: 'unpublished' }
+            : Number.isFinite(Date.parse(injected)) ? { kind: 'published', at: injected }
+              : { kind: 'unmeasured', reason: 'injected-published-at-invalid' }
+          : actualPublicationProbe(schedule.version, releaseRoot),
+        greenObserved: observed.some(row => row.phase === 'green-back'),
+      });
+    }
+    const selected = selectReleaseDaySchedules(schedules, now, version => states.get(version)!);
+    if (!selected.length) { log('decision', { phase: 'none', reason: 'outside-release-window', at: now.toISOString(), recorded: false, mode: 'shadow' }); return []; }
+    const results: ReleaseDayShadowResult[] = [];
+    for (const schedule of selected) {
+      const publication = states.get(schedule.version)!.publication;
+      if (publication.kind === 'unmeasured') {
+        const result: ReleaseDayShadowResult = { version: schedule.version, phase: 'unmeasured', dueAt: null,
+          scheduleUpdatedAt: schedule.updatedAt, reason: publication.reason, recorded: false };
+        log('unmeasured', { ...result, at: now.toISOString(), mode: 'shadow' });
+        results.push(result);
+        continue;
+      }
+      const publishedAt = publication.kind === 'published' ? publication.at : null;
+      const decision = decideReleaseDayPhase(schedule, now, publishedAt);
+      let recorded = false;
+      if (decision.phase !== 'none') {
+      const row = db.query('INSERT OR IGNORE INTO phase_observations (version, phase, due_at, observed_at, schedule_updated_at) VALUES (?, ?, ?, ?, ?)')
+        .run(decision.version, decision.phase, decision.dueAt!, now.toISOString(), decision.scheduleUpdatedAt);
+      recorded = row.changes === 1;
+      }
+      log('decision', { ...decision, at: now.toISOString(), recorded, mode: 'shadow', publishedAt });
+      results.push({ ...decision, recorded });
+    }
+    return results;
+  } finally { db.close(); }
+}
+
+if (import.meta.main) {
+  try {
+    const sinkReady = await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('steward');
+    if (!sinkReady) throw new Error('durable log sink unavailable');
+    const results = runReleaseDayShadow();
+    console.log(`steward release-day shadow: ${results.map(result => `${result.version}:${result.phase}${result.recorded ? ' · recorded' : ''}`).join(', ') || 'none'}`);
+  }
+  catch (error) { console.error(`steward release-day shadow failed: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+}

package/src/steward/resync-tick.ts

@@ -0,0 +1,123 @@
+/** Resync labeled PRs before the steward's TA rejudge node sees their heads. */
+import { debug } from '../debug/log.js';
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { resolveHqLaunchSeat } from '../hq/seats.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { runResyncShadow, type ResyncShadowSummary } from '../loops/orchestrator/resync-shadow.js';
+import { listSchedules, type ReleaseSchedule } from '../release-loop/release-schedule.js';
+
+type ReleaseRunState = 'active' | 'idle' | 'unknown';
+type ReleaseWindowState = 'inside' | 'outside' | 'unknown';
+type ResyncTickResult = { decision: 'ran' | 'failed' | 'skipped-release' | 'skipped-release-window'; summary?: ResyncShadowSummary; reason?: string };
+
+export function resyncPendingPath(): string { return join(effectiveInstanceRoot(), 'steward', 'resync-pending.json'); }
+
+/** The same registered, detached OP checkout used by steward launch; the installed package is not a git repository. */
+export function stewardResyncRepoRoot(
+  resolveSeat: typeof resolveHqLaunchSeat = resolveHqLaunchSeat,
+  configDir: () => string = getElanousConfigDir,
+): string { return resolveSeat('OP', configDir()); }
+
+/** A release may detach the OP checkout. Unknown process state also skips remote branch writes. */
+export function probeReleaseRun(
+  list: () => { status: number | null; stdout?: string; error?: Error } = () => spawnSync('pgrep', ['-f', 'release[[:space:]]+(run|resume)'], { encoding: 'utf8', timeout: 5_000 }),
+  command: (pid: string) => string | null = pid => {
+    const result = spawnSync('ps', ['-p', pid, '-o', 'command='], { encoding: 'utf8', timeout: 5_000 });
+    return result.status === 0 ? result.stdout.trim() : null;
+  },
+): ReleaseRunState {
+  try {
+    const result = list();
+    if (result.error || result.status === null) return 'unknown';
+    if (result.status === 1) return 'idle';
+    if (result.status !== 0) return 'unknown';
+    const pids = (result.stdout ?? '').trim().split(/\s+/).filter(pid => /^\d+$/.test(pid));
+    if (!pids.length) return 'unknown';
+    for (const pid of pids) {
+      const argv = command(pid);
+      if (argv === null) continue;
+      const executable = argv.trim().split(/\s+/)[0]?.split('/').at(-1);
+      if (['bun', 'node', 'eln', 'elanous'].includes(executable ?? '') && /(?:^|\s)release\s+(?:run|resume)(?:\s|$)/.test(argv)) return 'active';
+      // pgrep saw a release-shaped command, but a shell/wrapper cannot prove whether it will launch the CLI.
+    }
+    return 'unknown';
+  } catch { return 'unknown'; }
+}
+
+/** A release cut may start after the process probe; the scheduled cut/publication window is a fixed safety boundary. */
+export function releaseWindowState(
+  nowMs = Date.now(),
+  read: () => ReleaseSchedule[] = listSchedules,
+): ReleaseWindowState {
+  try {
+    const schedules = read();
+    if (!schedules.length) return 'unknown';
+    const rows = schedules.map(row => ({ cut: Date.parse(row.cutAt), publish: Date.parse(row.publishAt ?? '') }));
+    if (rows.some(row => !Number.isFinite(row.cut))) return 'unknown';
+    const latestPast = rows.filter(row => row.cut <= nowMs).sort((a, b) => b.cut - a.cut)[0];
+    if (latestPast && !Number.isFinite(latestPast.publish)) return 'unknown';
+    if (latestPast && nowMs <= latestPast.publish + 60 * 60_000) return 'inside';
+    const next = rows.filter(row => row.cut > nowMs).sort((a, b) => a.cut - b.cut)[0];
+    if (!next || !Number.isFinite(next.publish) || next.publish < next.cut) return 'unknown';
+    return nowMs >= next.cut - 40 * 60_000 ? 'inside' : 'outside';
+  } catch { return 'unknown'; }
+}
+
+export function defaultResyncRun(
+  repoRoot = stewardResyncRepoRoot(),
+  execute: typeof runResyncShadow = runResyncShadow,
+): Promise<ResyncShadowSummary> { return execute(3, { repoRoot }, 'live'); }
+
+export async function resyncTick(
+  run: () => Promise<ResyncShadowSummary> = () => defaultResyncRun(),
+  log: (event: string, data: Record<string, unknown>) => void = (event, data) => debug.log('loop.steward', event, data),
+  pendingPath: string = resyncPendingPath(),
+): Promise<ResyncTickResult> { return resyncTickWithReleaseProbe(run, log, pendingPath, probeReleaseRun); }
+
+export async function resyncTickWithReleaseProbe(
+  run: () => Promise<ResyncShadowSummary>,
+  log: (event: string, data: Record<string, unknown>) => void,
+  pendingPath: string,
+  releaseProbe: () => ReleaseRunState,
+  windowProbe: () => ReleaseWindowState = releaseWindowState,
+): Promise<ResyncTickResult> {
+  let result: ResyncTickResult;
+  try {
+    const release = releaseProbe();
+    if (release !== 'idle') {
+      result = { decision: 'skipped-release', reason: release === 'active' ? 'release run active' : 'release process probe unavailable' };
+    } else {
+      const window = windowProbe();
+      if (window !== 'outside') {
+        result = { decision: 'skipped-release-window', reason: window === 'inside' ? 'scheduled release window' : 'release schedule unavailable' };
+      } else {
+        const summary = await run();
+        if (summary.saved > 0) {
+          mkdirSync(dirname(pendingPath), { recursive: true });
+          writeFileSync(pendingPath, JSON.stringify({ savedAt: new Date().toISOString() }));
+        }
+        result = { decision: 'ran', summary };
+      }
+    }
+  }
+  catch (error) { result = { decision: 'failed', reason: (error instanceof Error ? error.message : String(error)).slice(-300) }; }
+  try { log('resync-tick', { ...result }); }
+  catch (error) {
+    result = { decision: 'failed', reason: `log failed: ${error instanceof Error ? error.message : String(error)}`.slice(-300) };
+    console.error(`steward resync: ${result.reason}`);
+  }
+  return result;
+}
+
+if (import.meta.main) {
+  let sinkReady = false;
+  try { sinkReady = await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('steward'); }
+  catch (error) { console.error(`steward resync: log sink registration failed — ${error instanceof Error ? error.message : String(error)}`); }
+  // A missing durable sink must not precede a remote branch update.
+  const result = sinkReady ? await resyncTick() : { decision: 'failed' as const, reason: 'log sink unavailable' };
+  console.log(`steward resync: ${result.decision}${result.reason ? ` — ${result.reason}` : ''}`);
+  process.exitCode = 0;
+}