tumwater 0.1.2 → 0.2.0

package/dist/src/tick/tick-finalize.js

@@ -17,27 +17,28 @@ const CLAIM_RELEASING = new Set([
  * happens AFTER the pi run, extracted from LoopRunner.tick (src/loop/loop.ts) so the runner keeps
  * only tick lifecycle (worktree, sessions, abort) and this module owns the per-result
  * bookkeeping policy. Order matters here and is pinned by behavior, not by a test seam: the
- * outcome's folds land on state before applyTickOutcome schedules the next run, the main-head
- * read happens while `running` is still true (a poll landing in that window must not double-wake
- * the loop), and the warnings read the streaks exactly once per episode, after the schedule. */
+ * outcome's folds are applied to state before applyTickOutcome schedules the next run, the
+ * main-head read happens while `running` is still true (a poll that runs in that window must not
+ * double-wake the loop), and the warnings read the streaks exactly once per episode, after the
+ * schedule. */
 export async function finalizeTick(deps) {
     const { root, role, mainBranch, config, state: s, usage, tick } = deps;
     let { outcome } = deps;
-    // A re-queued leftover's landing failure is not the tick's own result, so it rides the
+    // A re-queued leftover's merge failure is not the tick's own result, so it rides the
     // outcome separately: applyTickOutcome feeds it into the error streak, and the warning
     // below names it — even though runTick cleared `lastError` so it never latched onto
-    // `tick_end` (BUGS.md 2026-09-21).
+    // `run_end` (BUGS.md 2026-09-21).
     if (deps.recoveryFailure !== undefined)
         outcome.recoveryFailure = deps.recoveryFailure;
     // A main_red tick's cause is written for that result (src/baseline/main-red.ts), not a leftover
-    // landing failure: fold it onto the state here so `tick_end` logs it like every other
+    // merge failure: fold it onto the state here so `run_end` logs it like every other
     // failure's and the digest can itemize what the Outcome table's main_red cells mean
     // (BUGS.md 2026-09-28). runTick cleared `lastError` at its start, so nothing foreign
     // can precede this.
     if (outcome.error !== undefined)
         s.lastError = outcome.error;
     // Read main's current head while this tick is still reserved (running=true): the
-    // applyTickOutcome below clears running, and a poll landing between that clear and a later
+    // applyTickOutcome below clears running, and a poll that runs between that clear and a later
     // head update would see a stale lastMainHead and wake the loop again on the very move
     // that triggered this tick — a duplicate wake event plus an extra tick for one world change.
     // branchHead reads the ref files first (microsecond-scale, like the orchestrator's per-poll
@@ -57,22 +58,22 @@ export async function finalizeTick(deps) {
         !hasOutstandingWork(s)) {
         const title = s.claim.title;
         s.claim = undefined;
-        logEventBestEffort(root, { loop: role, type: "claim", action: "released", title, reason: outcome.result });
+        logEventBestEffort(root, { source: role, type: "claim", action: "released", title, reason: outcome.result });
     }
     // A wake consumed while this tick ran stamped the shared state in place, but the outcome
-    // schedule above overwrites it (lastTickEndedAt past wokenAt, nextRunAt a fresh gap or
+    // schedule above overwrites it (lastRunEndedAt past wokenAt, nextRunAt a fresh gap or
     // backoff out), so a plain `tumwater wake --role` with an empty queue would silently wait
     // out the whole interval (BUGS.md 2026-09-25). Re-apply it here — exactly like a wake
     // arriving one poll after the tick ended.
     restoreMidTickWake(s);
     saveLoopState(root, s);
     // One warning per error episode (BUGS.md 2026-09-15: every loop failing identically
-    // looked like a quiet fleet). applyTickOutcome increments the streak on error-class
-    // outcomes, preserves it across a plain `queued` tick (the tick's landing resolves it),
+    // looked like a quiet team). applyTickOutcome increments the streak on error-class
+    // outcomes, preserves it across a plain `queued` tick (the tick's merge resolves it),
     // and resets it on any other completed result — so warn only when THIS outcome incremented
     // the streak up to the threshold: a preserved streak already sitting at the bar must not
-    // re-warn on the queued tick's end. A rejection's crossing warns from the landing side
-    // instead (writeLandingOutcome, src/landing/landing-slot.ts), which is where rejections resolve.
+    // re-warn on the queued tick's end. A rejection's crossing warns from the merge side
+    // instead (writeMergeOutcome, src/merge/merge-slot.ts), which is where rejections resolve.
     if ((outcome.result === "error" || outcome.recoveryFailure !== undefined) &&
         (s.consecutiveErrors ?? 0) === ERROR_STREAK_WARN) {
         warnEventBestEffort(root, role, consecutiveFailuresWarning(s.consecutiveErrors ?? 0, s.lastError ?? outcome.recoveryFailure ?? "unknown error"));
@@ -82,21 +83,21 @@ export async function finalizeTick(deps) {
     // streak on each kill and resets it on any other result, so the crossing fires once;
     // the give-up (fresh session + backoff) follows on the next kill.
     if ((s.quietKillStreak ?? 0) === QUIET_KILL_RESUME_LIMIT) {
-        warnEventBestEffort(root, role, `${s.quietKillStreak} consecutive quiet kills (no progress): ${s.lastError ?? "unknown hang"}`);
+        warnEventBestEffort(root, role, `${s.quietKillStreak} consecutive stalls (no progress): ${s.lastError ?? "unknown hang"}`);
     }
     // Per-tick usage: the event feed is where operators see
-    // spend — this tick's tokens and cost ride on tick_end so a budget pause or a money-burning
+    // spend — this tick's tokens and cost ride on run_end so a budget pause or a money-burning
     // no_change/error/rejected/refused tick shows what it spent without diffing status-table
     // snapshots. Both fields are per-tick windows (reset at tick start, folded in over every
     // pi run of the tick); they ride on HarnessEvent's index signature like other payloads and
     // are omitted when zero so skipped ticks render byte-identical to a pre-feature line.
-    // The tick's wall-clock span rides on tick_end too: the
+    // The tick's wall-clock span rides on run_end too: the
     // failure digest prices a tick by its own durationMs first (src/failure/failure-data.ts
     // tickDurationMs), so the field is ALWAYS present — a tick that ends within the same
     // Date.now() millisecond it started (an instant early-abort error tick) or crosses a
     // backward clock step still attests its 0 ms, where the old omit-when-zero convention
-    // dropped the field and broke the "every tick_end carries a span" contract (BUGS.md
-    // 2026-09-29). Unlike the usage fields, tick_end's renderer never prints the span, so an
+    // dropped the field and broke the "every run_end carries a span" contract (BUGS.md
+    // 2026-09-29). Unlike the usage fields, run_end's renderer never prints the span, so an
     // always-present 0 changes no rendered line.
     const tickDurationMs = Math.max(0, Date.now() - deps.tickStartedAt);
     // The account state (plans/agent-backends.md part 6a): fold this tick's billing answer and
@@ -111,22 +112,28 @@ export async function finalizeTick(deps) {
             // The next reporting run rewrites it; nothing this tick depends on is lost.
         }
     }
+    // The per-provider split of this tick's usage (plans: per-provider spend in the day
+    // report): a Record<provider, {costUsd, notionalCostUsd}> for the report's `Cost by
+    // provider` line. Omitted when empty like the prompt-token fields, so a tick whose runs
+    // carried no provider renders byte-identically to today.
+    const providerCost = usage.serializeProviderCost();
     logEventBestEffort(root, {
-        loop: role,
-        type: "tick_end",
-        tick,
+        source: role,
+        type: "run_end",
+        run: tick,
         result: outcome.result,
         summary: outcome.summary,
         error: s.lastError,
         durationMs: tickDurationMs,
         ...usageFragment(s.generatedTokens, usage.costUsd, usage.notionalCostUsd),
+        ...(Object.keys(providerCost).length > 0 ? { providerCost } : {}),
         // The billing answer the tick's runs reported, so the report can tell notional spend from
         // real spend without re-deriving it from the file (plans/agent-backends.md part 6a).
         ...(usage.billing !== undefined ? { billing: usage.billing } : {}),
         // Per-tick prompt-token telemetry: how many prompt
         // tokens the tick sent, how many were cache reads, and how many went out before its first
         // edit. Omitted when zero like usageFragment's fields, so a tick that sent no prompt — and
-        // every tick_end written by an older build — renders byte-identically.
+        // every run_end written by an older build — renders byte-identically.
         ...(usage.promptTokens > 0 ? { promptTokens: usage.promptTokens } : {}),
         ...(usage.cacheReadTokens > 0 ? { cacheReadTokens: usage.cacheReadTokens } : {}),
         ...(usage.preEditPromptTokens > 0 ? { preEditPromptTokens: usage.preEditPromptTokens } : {}),

package/dist/src/tick/tick-outcome.js

@@ -1,4 +1,5 @@
-/** What a finished tick or landing is (the TickResult/TickOutcome vocabulary), shared by the
+// vocabulary: plain
+/** What a finished tick or merge is (the TickResult/TickOutcome vocabulary), shared by the
  * runner that produces it, the dashboards that render it, and the state machine that applies
  * it. The application policy — which outcomes count which streaks, when a session resumes,
  * how the next run is scheduled — lives next door in tick-apply.ts; the clock arithmetic it

package/dist/src/tick/tick-prompt.js

@@ -5,26 +5,45 @@ import { configForRole } from "../config/config-views.js";
 import { NOTHING_TO_DO } from "../verdict/reply-contract.js";
 import { dequeuePromptEntry, dequeueRolePromptEntry, peekPrompt, peekRolePrompt } from "../inbox/inbox.js";
 import { stripNotBeforeMarker } from "../inbox/prompt-not-before.js";
-import { readBrief } from "../brief.js";
+import { readBrief } from "../brief/brief.js";
 import { buildDirectorPrompt, buildTickPrompt } from "../prompt/prompt.js";
 import { readPrinciples } from "../prompt/principles.js";
 import { buildCutOffNote } from "../prompt/prompt-followup.js";
-import { buildAssignmentNote, buildConflictDiscardNote, buildHeldEntriesNote, buildRejectedReviewNote } from "../prompt/gate-prompts.js";
-import { eligibleEntries } from "../backlog/backlog-eligibility.js";
+import { buildAssignmentNote, buildConflictDiscardNote, buildHeldEntriesNote, buildMergedPrerequisitesNote, buildRejectedReviewNote, buildWaitingPartsNote } from "../prompt/gate-prompts.js";
+import { eligibleEntries, mergedPrerequisiteRanges, waitingPartRanges } from "../backlog/backlog-eligibility.js";
 import { detectBuildCheck } from "../build/build-check-detect.js";
+import { flakeCounts, KNOWN_FLAKE_WINDOW_MS } from "../review/known-flakes.js";
+import { readEventsSince } from "../events/event-window.js";
 import { telemetryDigest } from "./telemetry-digest.js";
 import { readQaCoverage, renderCoverageBlock } from "./qa-coverage.js";
 import { roleNotesPath } from "../paths.js";
-import { readTextOrNull } from "../files/files.js";
-import { ROLE_NOTES_MAX_BYTES } from "../pi-extension/role-notes.js";
+import * as path from "node:path";
+import { pathTokens } from "./stage-check.js";
+import { readTextOrNull, statOrNull } from "../files/files.js";
+import { dayKey } from "../text/datetime.js";
+import { appendPromptNote } from "../text/format.js";
+import { ROLE_NOTES_MAX_BYTES } from "../agent/role-notes-write.js";
 import { truncateWithNote } from "../text/text.js";
 import { renderBacklogIndexBlock, renderBacklogStructureBlock } from "../backlog/backlog-structure.js";
+/** The repo paths the entry at `file` lines `range` names that are absent from the checkout at
+ * `root`: tokens whose first segment is a directory there but which do not exist themselves —
+ * the self-check's top-level-directory rule, read from the working tree. */
+function missingEntryPaths(root, file, range) {
+    const text = readTextOrNull(path.join(root, file));
+    if (text === null)
+        return [];
+    const entry = text.split("\n").slice(range.start - 1, range.end).join("\n");
+    return pathTokens(entry).filter((p) => {
+        const top = p.slice(0, p.indexOf("/"));
+        return statOrNull(path.join(root, top))?.isDirectory() === true && statOrNull(path.join(root, p)) === null;
+    });
+}
 /** Read a role's notebook through files.ts's readTextOrNull — the one read-and-swallow
  * step — or undefined when it is missing or unreadable (an empty or whitespace-only note is
  * left for buildTickPrompt to omit). The degradation is deliberate: a torn or absent
  * runtime-state file must never fail a tick.
  *
- * The note is bounded on read as well as on write: the role_notes tool rejects text over
+ * The note is bounded on read as well as on write: the write path rejects text over
  * ROLE_NOTES_MAX_BYTES, but the file lives in hand-editable runtime state, so an oversized
  * note (an old build, a manual edit) would otherwise ride into every one of this role's
  * prefill-heavy tick prompts uncapped. The same defensive backstop readPrinciples and the
@@ -34,7 +53,30 @@ import { renderBacklogIndexBlock, renderBacklogStructureBlock } from "../backlog
  * marker naming the loss. */
 function readRoleNote(root, role) {
     const text = readTextOrNull(roleNotesPath(root, role));
-    return text === null ? undefined : truncateWithNote(text, ROLE_NOTES_MAX_BYTES, "role notebook");
+    return text === null ? undefined : truncateWithNote(text, ROLE_NOTES_MAX_BYTES, "role notes");
+}
+/** The bugfix run's tally of checks the merge gate excused as flaky in the last day, or
+ * undefined when none (or the log is unreadable — a missing tally never fails a run). */
+function flakyChecksNote(root) {
+    let counts;
+    try {
+        counts = flakeCounts(readEventsSince(root, KNOWN_FLAKE_WINDOW_MS).events);
+    }
+    catch {
+        return undefined;
+    }
+    if (counts.length === 0)
+        return undefined;
+    const shown = counts
+        .slice(0, 5)
+        .map(([key, n]) => `"${key}" ×${n}`)
+        .join("; ");
+    const more = counts.length > 5 ? ` (and ${counts.length - 5} more)` : "";
+    return (`Flaky checks: in the last 24h the merge gate excused these check failures as flaky (each ` +
+        `failed, then passed on its one re-run), most frequent first: ${shown}${more}. An excused ` +
+        `flake blocks no merge, so it stays unfixed until it has a BUGS.md entry. When an open bug ` +
+        `names one of these, that bug is still firing. When \`## Open\` holds no entries, a check ` +
+        `excused 2 or more times is a confirmed latent bug: take it as this run's latent-bug candidate.`);
 }
 /** Assemble the prompt a loop's next tick runs on — the whole "what should this tick see"
  * concern, split out of loop.ts so the runner owns only lifecycle and the prompt owns only
@@ -43,7 +85,7 @@ function readRoleNote(root, role) {
  * queued by `tumwater prompt --role <id>` — back so the runner can record it as pending and
  * re-queue it if the tick leaves it unfulfilled; `userPromptFile` is the queue file it came
  * from, so that bookkeeping can clean the prompt's attachments by that file's stem. */
-export function assembleTickPrompt({ root, config, role, state, preview = false, agent }) {
+export function assembleTickPrompt({ root, config, role, state, preview = false, agent, compact = false }) {
     // One read of the brief yields both the prompt it carries and the owning file's name
     // (brief.ts's readBrief): readInitialPrompt + briefFile were two full reads of the same
     // file on this per-tick path.
@@ -51,7 +93,7 @@ export function assembleTickPrompt({ root, config, role, state, preview = false,
     const initialPrompt = briefState?.prompt ?? "";
     // The brief's owning file (TUMWATER.md first, README.md as the compatibility path —
     // plans/portability.md §7a/7), named in both prompt builders' rules instead of a hardcoded
-    // README.md. "README.md" is the fallback for a repo with no marked file yet — the fleet
+    // README.md. "README.md" is the fallback for a repo with no marked file yet — the team
     // runs blind on prompts either way, so the name in the rules should still point somewhere.
     const brief = briefState?.file ?? "README.md";
     // The project's design principles ride along in every prompt — tick and director alike — so
@@ -79,24 +121,26 @@ export function assembleTickPrompt({ root, config, role, state, preview = false,
             return null;
         userPrompt = stripNotBeforeMarker(dequeued);
         userPromptFile = entry?.file ?? null;
-        prompt = buildDirectorPrompt(userPrompt, initialPrompt, principles, check, brief, undefined, backlogIndex, agent ?? configForRole(config, DIRECTOR_ROLE).agent);
+        // The compact prompt leaves the brief block out: the director reads the brief file in full,
+        // and that file carries the same text.
+        prompt = buildDirectorPrompt(userPrompt, compact ? "" : initialPrompt, principles, check, brief, undefined, backlogIndex, agent ?? configForRole(config, DIRECTOR_ROLE).agent, compact, config.roles[DIRECTOR_ROLE]?.instructions);
     }
     else {
         // The loop id keys its inbox and notebook; every lookup ABOUT the role — catalog charter,
-        // instructions, the qa/telemetry/clean blocks — resolves through the base role, so
+        // instructions, the qa/selfcheck/clean blocks — resolves through the base role, so
         // `feature-2` runs the feature charter and `roles.feature.instructions` while keeping its
         // own queue and notes (plans/parallel-work-instances.md).
         const base = baseRoleOf(role);
         // Catalog first, then user-defined loops (plans/user-defined-loops.md): a custom's task
         // is its entire find-something-to-do text and the title identifies it in the prompt.
-        const custom = config.customLoops.find((c) => c.name === role);
+        const custom = config.customRoles.find((c) => c.name === role);
         const resolved = roleById(role) ?? (custom ? customRole(custom.name, custom.task) : undefined);
         if (!resolved) {
             // The shared unknownRoleMessage (parseRoleFlag, the operator commands) names the valid
             // ids; this defensive path — a runner asked to tick a role no catalog entry or
-            // customLoops task can answer — says the same, so if it ever fires it reads as the
+            // customRoles task can answer — says the same, so if it ever fires it reads as the
             // harness bug it is instead of a bare dead end.
-            const validIds = [...allRoleIds(), ...config.customLoops.map((c) => c.name)];
+            const validIds = [...allRoleIds(), ...config.customRoles.map((c) => c.name)];
             throw new Error(unknownRoleMessage(role, validIds));
         }
         // A queued per-role prompt is dequeued here, before the prompt is built, so its text rides
@@ -109,9 +153,9 @@ export function assembleTickPrompt({ root, config, role, state, preview = false,
         const entry = preview ? null : dequeueRolePromptEntry(root, role);
         const dequeued = preview ? peekRolePrompt(root, role) : entry?.text ?? null;
         const request = dequeued === null ? null : stripNotBeforeMarker(dequeued);
-        // The telemetry role's evidence is the harness's own event log, one level outside this
+        // The selfcheck role's evidence is the harness's own event log, one level outside this
         // worktree, so its evidence module renders it (telemetryDigest) and the tick injects it.
-        const digest = base === "telemetry" ? telemetryDigest(root) : undefined;
+        const digest = base === "selfcheck" ? telemetryDigest(root) : undefined;
         // The `qa` observer's flow rotation needs a memory of what it last exercised; every tick
         // is a fresh session, and a passing cheap check leaves nothing in the repo. The ledger is
         // runtime state, and a missing or unreadable one degrades to no block
@@ -134,31 +178,47 @@ export function assembleTickPrompt({ root, config, role, state, preview = false,
         // instruction in buildTickPrompt is present either way. The director branch above never
         // reads this path, so it carries no notebook.
         const notes = readRoleNote(root, role);
+        // The note file's mtime is when the notes were last saved (writes replace the file), so the
+        // run can weigh how stale they are.
+        const savedStat = notes === undefined ? null : statOrNull(roleNotesPath(root, role));
+        const notesSavedDay = savedStat ? dayKey(savedStat.mtimeMs) : undefined;
         // The plan charter's stop threshold is derived from config (plans/parallel-work-
         // instances.md "…keeping the plan loop ahead", part 5c/7). The catalog text stays a
         // config-free description of the rule; this note supplies the concrete eligible-plan count
         // so the plan loop stops only once every configured feature instance has a plan waiting.
         const planTargetNote = base === "plan"
-            ? `This tick's stop target: when PLANS.md \`## Planned\` already holds ` +
-                `${planBacklogTarget(config)} or more eligible plans, end with ${NOTHING_TO_DO}.`
+            ? `This run's stop target: when PLANS.md \`## Planned\` already holds ` +
+                `${planBacklogTarget(config)} or more eligible plans, end with ${NOTHING_TO_DO}. ` +
+                `It holds ${eligibleEntries(root, "feature").length} now (tumwater's count of entries ` +
+                `feature could take, the same count that decides whether a plan run is deferred).`
             : undefined;
+        const flakyChecks = base === "bugfix" ? flakyChecksNote(root) : undefined;
+        // A run holding a claim with no queued request is assigned its one entry (the assignment
+        // note below). In the compact prompt such a run reads that entry first, so the backlog index
+        // — what an unassigned run chooses its task from — stays out. The brief block stays out of
+        // every compact prompt: an unassigned run reads the brief file in full, which carries the
+        // same text, and an assigned one reads it only when its entry needs it.
+        const variant = compact ? { assigned: state.claim !== undefined && request === null } : undefined;
         prompt = buildTickPrompt({
             role: resolved,
-            initialPrompt,
+            initialPrompt: compact ? "" : initialPrompt,
             principles,
             digest,
             coverage,
             backlogStructure,
-            backlogIndex,
+            backlogIndex: variant?.assigned ? undefined : backlogIndex,
             notes,
+            notesSavedDay,
             planTargetNote,
+            flakyChecks,
             extraInstructions: config.roles[base]?.instructions,
             check,
             briefFile: brief,
             agent: agent ?? configForRole(config, role).agent,
+            compact: variant,
             // A per-role prompt queued by `tumwater prompt --role <id>` rides as an explicit user
             // request block; its text is also the tick's userPrompt,
-            // so the runner's pending-prompt machinery (re-queue on unfulfilled, clear on landing)
+            // so the runner's pending-prompt machinery (re-queue on unfulfilled, clear on merge)
             // treats it exactly like the director's dequeued request.
             userRequest: request ?? undefined,
         });
@@ -175,27 +235,35 @@ export function assembleTickPrompt({ root, config, role, state, preview = false,
     const claim = role === DIRECTOR_ROLE ? undefined : state.claim;
     if (claim && userPrompt === null) {
         const range = eligibleEntries(root, role).find((e) => e.key === claim.key);
-        prompt += `\n\n${buildAssignmentNote(claim, range)}`;
+        prompt = appendPromptNote(prompt, buildAssignmentNote(claim, range, range ? missingEntryPaths(root, claim.file, range) : []));
+        const merged = claim.file === "PLANS.md" ? mergedPrerequisiteRanges(root, claim.title) : [];
+        if (merged.length > 0)
+            prompt = appendPromptNote(prompt, buildMergedPrerequisitesNote(merged, compact));
+    }
+    if (claim && userPrompt === null && claim.file === "PLANS.md") {
+        const waiting = waitingPartRanges(root, claim.title);
+        if (waiting.length > 0)
+            prompt = appendPromptNote(prompt, buildWaitingPartsNote(waiting, compact));
     }
     if (!claim && userPrompt === null && role !== DIRECTOR_ROLE && state.heldElsewhere?.length) {
-        prompt += `\n\n${buildHeldEntriesNote(state.heldElsewhere)}`;
+        prompt = appendPromptNote(prompt, buildHeldEntriesNote(state.heldElsewhere));
     }
     // A change rejected in review is the only cross-tick memory of what was built and why it
     // failed — every tick starts a fresh session, so the full reasons ride along on the next
     // prompt until the role's next reviewed change replaces them.
     if (state.lastReview?.verdict === "reject" && !state.revision) {
-        prompt += `\n\n${buildRejectedReviewNote(state.lastReview, role)}`;
+        prompt = appendPromptNote(prompt, buildRejectedReviewNote(state.lastReview, role));
     }
     // Likewise a change leftover recovery discarded as unmergeable: named until the role queues
     // its next change (the discarding tick itself appends it after recovery — see runTick).
     const discard = state.conflictDiscard;
     if (discard)
-        prompt += `\n\n${buildConflictDiscardNote(discard.summary, discard.attempts)}`;
+        prompt = appendPromptNote(prompt, buildConflictDiscardNote(discard.summary, discard.attempts));
     // A fresh tick after the previous run(s) were cut off at the context ceiling (the loop
     // stopped resuming, or never resumed — the director re-runs its prompt fresh): the only
     // memory that the last attempt was too big for the window is this note.
     if ((state.cutOffStreak ?? 0) > 0) {
-        prompt += `\n\n${buildCutOffNote(state.cutOffStreak ?? 0)}`;
+        prompt = appendPromptNote(prompt, buildCutOffNote(state.cutOffStreak ?? 0));
     }
     return { prompt, userPrompt, userPromptFile };
 }

package/dist/src/tick/tick-resume.js

@@ -1,6 +1,6 @@
 import { agentSessionResumable } from "../agent/agent-backend.js";
 import { latestSession } from "../agent/session-ledger.js";
-import { RETRIABLE_LANDING_RESULTS } from "../landing/landing-core.js";
+import { RETRIABLE_MERGE_RESULTS } from "../merge/merge-core.js";
 import { sessionDir } from "../paths.js";
 import { buildHandoffPrompt, buildResumePrompt } from "../prompt/prompt-followup.js";
 /** Decide how a tick starts, consuming the resume flags as a side effect (the flag is
@@ -10,12 +10,12 @@ import { buildHandoffPrompt, buildResumePrompt } from "../prompt/prompt-followup
  * inbox); a role loop's assembly never returns null. */
 export function planTickStart(opts) {
     const s = opts.state;
-    // The last landing's failure, read before the clear below: a landing that failed
-    // non-terminally kept its pin (the lander's own vocabulary — review_error, merge_conflict,
+    // The last merge's failure, read before the clear below: a merge that failed
+    // non-terminally kept its pin (the merger's own vocabulary — review_error, merge_conflict,
     // merge_blocked — with the detail it wrote into `lastError`), and when this tick's recovery
     // re-queues that pin, the failure must still feed the error streak (finishRecoveryTick).
-    const priorLandingFailure = s.lastResult !== undefined && RETRIABLE_LANDING_RESULTS.has(s.lastResult)
-        ? (s.lastError ?? `landing failed: ${s.lastResult}`)
+    const priorMergeFailure = s.lastResult !== undefined && RETRIABLE_MERGE_RESULTS.has(s.lastResult)
+        ? (s.lastError ?? `merge failed: ${s.lastResult}`)
         : undefined;
     s.lastError = undefined;
     // A tick interrupted by a harness shutdown left its pi session and its worktree's
@@ -42,7 +42,7 @@ export function planTickStart(opts) {
     // claude resumes an id (safe across a newer gate line). A backend with no `resumable` hook
     // falls back to the backend-neutral session-file check.
     const resumable = resumePending && !resumeMissing
-        ? agentSessionResumable(dir, { kind: "author", agent })
+        ? agentSessionResumable(dir, { kind: "author", agent }, opts.claudeConfigDir)
         : false;
     const resumableSession = resumable;
     // A newest line our backend cannot resume is not ours to continue: another kind's or
@@ -53,7 +53,7 @@ export function planTickStart(opts) {
     // session over the kept worktree, carrying the assembled tick prompt plus the handoff
     // bridge (plans/agent-backends.md "Sessions"). The failed `resumeMissing` run arms
     // `resumePending` and records `resumeMissing` from the verdict (its error turn carries no
-    // assistant content), so the very next tick lands here with the worktree intact. A dir with
+    // assistant content), so the very next tick ends up here with the worktree intact. A dir with
     // no ledger line at all is not a handoff — there is no recorded interrupted session to carry
     // forward.
     // Captured before the flag is consumed below; a stale cause must not leak into a later resume.
@@ -62,7 +62,12 @@ export function planTickStart(opts) {
     // survive, but the next run is a FRESH session — the fallback seam may be a different backend,
     // and claude keeps no flags across `--resume` (plans/agent-backends.md §7, part 7a/7).
     const budgetCapped = pendingResumeCause === "budget-capped";
-    const handoff = (latest !== null && !resumable) || budgetCapped;
+    // An image-blind run with an image-capable peer tier ends `aborted` with this cause
+    // (plans/image-input.md part 4/5): the next tick runs a FRESH session on the TARGET seam
+    // over the kept worktree — never `--continue` — because the old session carries pi's
+    // "image omitted" note and the target may be a different backend.
+    const imageReroute = pendingResumeCause === "image-reroute";
+    const handoff = (latest !== null && !resumable) || budgetCapped || imageReroute;
     s.resumePending = false;
     s.resumeCause = undefined;
     s.resumeMissing = undefined;
@@ -74,7 +79,7 @@ export function planTickStart(opts) {
     const resumeBlocked = s.phase === "review";
     // A budget-capped handback never resumes the session whose seam the cap moved off of, even
     // when its transcript is still resumable: it hands off instead.
-    const resuming = resumableSession && !resumeBlocked && !budgetCapped;
+    const resuming = resumableSession && !resumeBlocked && !budgetCapped && !imageReroute;
     const handingOff = handoff && !resumeBlocked;
     // Reclaim the prompt the interrupted tick re-queued for its resume (src/inbox/pending-prompt.ts):
     // the resumed session still owns that request in its context, so this tick's bookkeeping
@@ -91,19 +96,30 @@ export function planTickStart(opts) {
     const resumeCause = handingOff
         ? budgetCapped
             ? "budget-capped"
-            : "handoff"
+            : imageReroute
+                ? "image-reroute"
+                : "handoff"
         : pendingResumeCause ?? ((s.cutOffStreak ?? 0) > 0 ? "cut-off" : "restart");
     let prompt;
     if (resuming) {
         prompt = buildResumePrompt(opts.role, resumeCause, agent);
     }
     else {
-        const assembled = opts.tickPrompt(agent);
+        const assembled = opts.tickPrompt(agent, opts.compact);
+        // The image-reroute handoff note names the model the blind run was on and the image it
+        // read; those facts ride the one-shot marker, which is consumed here. A handoff's fresh
+        // session also needs the to-be-run model named for its own side of the note, but the
+        // bridge already carries the facts that matter.
+        const rerouteFacts = imageReroute && s.imageReroute
+            ? { from: s.imageReroute.from ?? "the prior model", path: s.imageReroute.path ?? "an image" }
+            : undefined;
+        if (imageReroute)
+            s.imageReroute = undefined;
         prompt =
             assembled === null
                 ? null
                 : handingOff
-                    ? buildHandoffPrompt(opts.role, assembled, resumeCause)
+                    ? buildHandoffPrompt(opts.role, assembled, resumeCause, rerouteFacts)
                     : assembled;
     }
     if (prompt === null)
@@ -111,5 +127,5 @@ export function planTickStart(opts) {
     // The raw user prompt a director tick is executing (null for role loops), so an
     // unfulfilled outcome below can re-queue it. Captured before the field is cleared.
     const userPrompt = opts.pending.get();
-    return { priorLandingFailure, resuming, handoff: handingOff, resumeCause, prompt, userPrompt };
+    return { priorMergeFailure, resuming, handoff: handingOff, resumeCause, prompt, userPrompt };
 }