omp-conductor 0.16.2 → 0.17.1

package/src/failure-class.ts

@@ -61,8 +61,14 @@ const SUCCESS_CHECK_STATES: Record<string, true> = { success: true, neutral: tru
  * Substrings in a failed check's log that prove the failure was infrastructure,
  * not the diff (#177). Each is a registry/docker/runner fault a worker cannot
  * have introduced: a rate limit, an image-manifest resolution failure, a runner
- * being torn down under the job, or a DNS failure. Matched lowercased against
- * the log tail.
+ * a runner being torn down under the job, or a DNS failure. Matched lowercased against
+ * the log tail. GitHub writes the rate-limit sentence "Response status code does
+ * not indicate success: 429 (Too Many Requests)" where Docker writes "429 Too
+ * Many Requests"; the full sentence is its own exact entry rather than a blanket
+ * paren-strip of the log — stripping every parenthesis would let a deterministic
+ * log like "failed to resolve source (metadata for fixture)" slip past the
+ * `failed to resolve source metadata for` signature and waive an attempt it
+ * genuinely spent (#177).
  *
  * Deliberately *not* matching bare `failed to solve:` — a docker build failure
  * often prints it with a real resolution error, so the closing words carry the
@@ -70,12 +76,46 @@ const SUCCESS_CHECK_STATES: Record<string, true> = { success: true, neutral: tru
  */
 const INFRA_LOG_SIGNATURES = [
   "429 too many requests",
+  // GitHub's setup/action-download sentence for the same rate limit — the full
+  // lowercased phrase, never the bare parenthesized status: an application log
+  // like "expected 200, got 429 (Too Many Requests)" is a product verdict, not
+  // the runner's, and must not be waived (#637, #639).
+  "response status code does not indicate success: 429 (too many requests)",
   "failed to resolve source metadata for",
   "the runner has received a shutdown signal",
   "could not resolve host",
 ];
 
-function normalise(state: string): string {
+/**
+ * The closed infra signature a failed check log must contain for the failure
+ * to be infrastructure rather than the diff, or `undefined` when the log
+ * carries none (#177). Exported so the historical reconciliation recognises
+ * exactly what the forward classifier does — one definition of "the log
+ * proves infra", or a repaired row and a fresh row would diverge (#638).
+ */
+export function infraLogSignature(log: string): string | undefined {
+  const lower = log.toLowerCase();
+  return INFRA_LOG_SIGNATURES.find((signature) => lower.includes(signature));
+}
+
+/**
+ * A stable fingerprint of the infrastructure signature list (#638). The
+ * historical reconciliation persists a per-project review cursor stamped with
+ * this version so a bounded pass resumes where the last one stopped; when the
+ * classifier learns a new signature, the fingerprint changes, the stored
+ * cursor is stale, and the pass restarts from the newest row so the newly
+ * recognised evidence is never skipped past. Two values are equal exactly when
+ * the signature set is — a join cannot collide, because each entry is a
+ * distinct delimiter-free token sequence.
+ */
+export function infraSignatureVersion(): string {
+  return INFRA_LOG_SIGNATURES.join("|");
+}
+
+/** Lowercased check state — `gh pr checks` has emitted both `failure` and
+ *  `FAILURE` across versions, and the classifier's callers must agree on one
+ *  spelling so log selection and classification see the same set of checks. */
+export function normalise(state: string): string {
   return state.trim().toLowerCase();
 }
 
@@ -466,16 +506,19 @@ export function classifyRun(
       // beats ci-deterministic because charging an implementation attempt for a
       // rate limit is exactly the waste that class exists to prevent.
       if (facts.failingLog !== undefined) {
-        const lower = facts.failingLog.toLowerCase();
-        for (const signature of INFRA_LOG_SIGNATURES) {
-          if (lower.includes(signature)) {
-            const check = checks.find((c) => normalise(c.state) === "failure");
-            return {
-              cls: "ci-infra",
-              recovery: "rerun-checks",
-              evidence: `infrastructure signature in ${check?.name === undefined ? "failed check" : check.name} log: "${signature}"`,
-            };
-          }
+        // Matched exactly, without paren-stripping: GitHub's full setup/codeload
+        // sentence is its own closed entry above, and a generic paren-strip would
+        // broaden the other signatures into waiving real deterministic failures
+        // (#177). A bare "429" or "too many requests" (parenthesized or not)
+        // still never matches without that sentence.
+        const signature = infraLogSignature(facts.failingLog);
+        if (signature !== undefined) {
+          const check = checks.find((c) => normalise(c.state) === "failure");
+          return {
+            cls: "ci-infra",
+            recovery: "rerun-checks",
+            evidence: `infrastructure signature in ${check?.name === undefined ? "failed check" : check.name} log: "${signature}"`,
+          };
         }
       }
       const failing = unresolved.filter((c) => normalise(c.state) === "failure");

package/src/fleet.ts

@@ -27,17 +27,31 @@ import {
 import { createInterface } from "node:readline";
 import { homedir } from "node:os";
 import { dirname, join, sep } from "node:path";
-import { findProject, loadConfig, stateDir } from "./config.ts";
+import { findProject, loadConfig, resolveArmProof, stateDir } from "./config.ts";
 import { clearArmChallenge, recordArmChallenge } from "./arm-challenge.ts";
-import { resolveClaimedSessionFile, resolveProjectTopicId, sendTelegram } from "./escalate.ts";
+import {
+  claimedTelegramTopics,
+  lockPidAlive,
+  pidAlive,
+  readTelegramDmOwner,
+  readTelegramPollState,
+  resolveClaimedSessionFile,
+  resolveProjectTopicId,
+  sendTelegram,
+  telegramPlumbingVerdict,
+  TELEGRAM_LOCK_FRESH_MS,
+  type TelegramPlumbingFailureReason,
+  type TelegramPlumbingProbe,
+  type TelegramPlumbingVerdict,
+} from "./escalate.ts";
 import { readPlanUsage, sharedUsageSource } from "./usage.ts";
 import { readApprovalSurface, readDaemonProfile } from "./approval-surface.ts";
 import { inspectBriefLayout } from "./brief-upgrade.ts";
 import { dbPath, openStore } from "./store.ts";
 import { renderBriefForProject } from "./setup.ts";
-import type { DaemonStop, ProjectConfig, Store } from "./types.ts";
+import { DEFAULT_ARM_PROOF, type ArmProof, type DaemonStop, type ProjectConfig, type Store } from "./types.ts";
 import { probeCodeGraph, type CodeGraphHealth } from "./graph-health.ts";
-import { isPaused, setPaused, statusSnapshot } from "./daemon.ts";
+import { isPaused, setPaused, statusSnapshot, type StatusSnapshot } from "./daemon.ts";
 import {
   healthCheck,
   isAlive,
@@ -68,6 +82,7 @@ import {
   resolveArmState,
   TICK_CONFIG_FILE,
   tickConfigMatchesProject,
+  type ArmState,
   type TickConfig,
   type TickConfigResult,
 } from "./orchestrator-tick.ts";
@@ -281,7 +296,13 @@ export interface ArmResult {
   path: string;
   alreadyArmed: boolean;
   owner: string;
-  challenge: string;
+  /** The challenge code that proved arming, present only for `challenge` proof. */
+  challenge?: string;
+  /**
+   * Which proof armed the fleet (#613): `challenge` for the authenticated
+   * round-trip, `claim-only` for the live-plumbing verdict with no send.
+   */
+  proof: ArmProof;
 }
 
 export interface ArmDeps {
@@ -306,6 +327,17 @@ export interface ArmDeps {
   now?: () => number;
   sleep?: (ms: number) => Promise<void>;
   timeoutMs?: number;
+  /**
+   * Liveness seams for the claim-only verdict (#613), with omp-telegram's own
+   * rules (#612): `pidAlive` judges a claim or dm-owner (EPERM is dead),
+   * `lockPidAlive` judges a bot.lock owner (EPERM is live), and `lockFresh`
+   * applies the heartbeat window. Tests inject deterministic answers without
+   * owning another uid's process; the verdict itself and every state file it
+   * reads run for real.
+   */
+  pidAlive?: (pid: number) => boolean;
+  lockPidAlive?: (pid: number) => boolean;
+  lockFresh?: (mtimeMs: number) => boolean;
 }
 
 export async function armTicks(projectName?: string, deps: ArmDeps = {}): Promise<ArmResult> {
@@ -346,14 +378,81 @@ export async function armTicks(projectName?: string, deps: ArmDeps = {}): Promis
   // answering a question they cannot attribute.
   const named = tick.config.project ?? projectName;
 
+  // The arming proof is a declared per-project policy (#613). A config that
+  // cannot name the project fails safe to `challenge` — today's authenticated
+  // round-trip — so a missing or unreadable config never silently weakens the
+  // gate.
+  let proof: ArmProof = DEFAULT_ARM_PROOF;
+  try {
+    proof = resolveArmProof(findProject(loadConfig(), named));
+  } catch {
+    /* no project config — keep today's challenge behaviour */
+  }
+
   // Resolve the orchestrator's live session file *before* the challenge goes
   // out — the same claim the send follows (#600). A pane resumed from a
   // session created elsewhere (herdr pins it to the original transcript)
   // writes a session file outside the directory the tick cwd implies, and a
   // cwd-derived scan would poll the one place the reply is guaranteed not to
   // be. A claim outside the session tree arm scans can never be answered, so
-  // that is a stop, not five minutes of polling.
+  // that is a stop, not five minutes of polling. (Claim-only resolves the
+  // claim too — the verdict checks the same session identity — but names the
+  // refusal itself rather than throwing the transcript wording.)
   const claimed = deps.claimedSessionFile !== undefined ? deps.claimedSessionFile() : claimedOrchestratorSessionFile(named);
+
+  // Prefer the project's live forum topic so arm challenges land where
+  // escalations already do (#318), following the bridge's current claim when the
+  // pinned id has gone stale (#407). Missing project config keeps flat-chat 0.13.
+  let sendTopic: number | undefined;
+  if (named !== undefined) {
+    try {
+      sendTopic = resolveProjectTopicId(findProject(loadConfig(), named));
+    } catch {
+      /* no project config */
+    }
+  }
+
+  const path = tick.config.armedFile;
+  // The gate as the heartbeat reads it, so "replaced previous marker" is not a
+  // lie about a fleet the shared marker was arming, and so the write below knows
+  // whether it is superseding that marker.
+  const arm = resolveArmState(path, named);
+  const alreadyArmed = arm.armed;
+
+  if (proof === "claim-only") {
+    // The human-intent gate is declared satisfied by policy, so #612's shared
+    // verdict is the whole proof: the same state reads and the same liveness
+    // rules the doctor's "telegram-plumbing" finding applies, on the route a
+    // challenge would have ridden. No Telegram send, no transcript wait, no
+    // pending-challenge record. A failed fact refuses arming by name — never
+    // a silent pass from file existence, and never a marker.
+    const scan = armVerdictScanDirs(tick.cwd, claimed);
+    const probe: TelegramPlumbingProbe = {
+      // `channel` is up here — the paired-channel block above already threw on
+      // down — but the verdict re-reads it from the same state the challenge
+      // would send over, so the two proofs cannot disagree about the transport.
+      channel,
+      registry: claimedTelegramTopics(),
+      poll: readTelegramPollState(),
+      dmOwner: readTelegramDmOwner(),
+      alive: deps.pidAlive ?? pidAlive,
+      lockAlive: deps.lockPidAlive ?? lockPidAlive,
+      fresh: deps.lockFresh ?? ((mtimeMs) => (deps.now ?? Date.now)() - mtimeMs < TELEGRAM_LOCK_FRESH_MS),
+    };
+    const verdict = telegramPlumbingVerdict(sendTopic, { dirs: scan }, probe);
+    if (!verdict.ok) {
+      throw new Error(
+        `arm: claim-only proof refused — ${claimOnlyFailureText(verdict.reason)}. ` +
+          `NOT armed; no marker was written`,
+      );
+    }
+    writeArmedMarker(path, channel.owner, arm);
+    return { path, alreadyArmed, owner: channel.owner, proof };
+  }
+
+  // The transcript proof needs a session tree to poll. The claim-only verdict
+  // needs no such thing — it reads session identity from omp-telegram's own
+  // state — so this stop stays on the challenge path only.
   const dirs = armSessionScanDirs(tick.cwd, claimed);
   if (dirs.every((d) => !existsSync(d))) {
     throw new Error(
@@ -362,30 +461,12 @@ export async function armTicks(projectName?: string, deps: ArmDeps = {}): Promis
     );
   }
 
-  const path = tick.config.armedFile;
-  // The gate as the heartbeat reads it, so "replaced previous marker" is not a
-  // lie about a fleet the shared marker was arming, and so the write below knows
-  // whether it is superseding that marker.
-  const arm = resolveArmState(path, tick.config.project ?? projectName);
-  const alreadyArmed = arm.armed;
   const code = makeChallengeCode();
   const text =
     `Fleet arming check${named === undefined ? "" : ` — project ${named}`}. ` +
     `Reply to this chat with exactly:\n${code}\n` +
     `Nothing will be dispatched until that reply is seen in the orchestrator session.`;
 
-  // Prefer the project's live forum topic so arm challenges land where
-  // escalations already do (#318), following the bridge's current claim when the
-  // pinned id has gone stale (#407). Missing project config keeps flat-chat 0.13.
-  let topicId: number | undefined;
-  if (named !== undefined) {
-    try {
-      topicId = resolveProjectTopicId(findProject(loadConfig(), named));
-    } catch {
-      /* no project config */
-    }
-  }
-
   const send = deps.sendChallenge ?? sendTelegramMessage;
   const timeoutMs = deps.timeoutMs ?? ARM_CHALLENGE_TIMEOUT_MS;
   // Read before the send, not after: a transcript untouched since this instant
@@ -397,7 +478,7 @@ export async function armTicks(projectName?: string, deps: ArmDeps = {}): Promis
   // and cleared the moment this end settles (#415).
   recordArmChallenge(named, code, sentAt + timeoutMs);
   try {
-    await send(token, channel.owner, text, topicId);
+    await send(token, channel.owner, text, sendTopic);
   } catch (err) {
     // The challenge never went out, so it must not linger as a classifiable
     // proof either.
@@ -443,18 +524,12 @@ export async function armTicks(projectName?: string, deps: ArmDeps = {}): Promis
     );
   }
 
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `armed ${new Date().toISOString()} owner=${channel.owner}\n`, { mode: 0o600 });
-  // This project now has its own marker, so the shared one it was borrowing has
-  // done its last job. Left in place it would survive the next `disarm` as a
-  // marker that re-arms the fleet, and turn into a meaningless legacy warning
-  // the moment a second project is configured.
-  if (arm.legacy === "honoured") rmSync(legacyArmedMarkerPath(), { force: true });
+  writeArmedMarker(path, channel.owner, arm);
   // The transcript proof landed and this project is armed: the record has done
   // its job. A stale record would also keep a later unsolicited lookalike alive
   // longer than the fresh challenge it was cut for.
   clearArmChallenge(named);
-  return { path, alreadyArmed, owner: channel.owner, challenge: code };
+  return { path, alreadyArmed, owner: channel.owner, challenge: code, proof };
 }
 
 export interface HoldResult {
@@ -1311,8 +1386,24 @@ function servedProjectName(payload: object): string | undefined {
   return undefined;
 }
 
-export async function renderStatus(projectName?: string): Promise<string> {
-  const s = statusSnapshot(projectName);
+export type FleetStatusReport = StatusSnapshot & {
+  observedAt: number;
+  layers: FleetLayers;
+  daemon: FleetDaemonProbe | undefined;
+  telegram: TelegramHealth;
+  codeGraph: CodeGraphHealth;
+  brief: string | undefined;
+  decisions: string | undefined;
+  failureClasses: string | undefined;
+  workerPhases: { issue: number; phase: WorkerPausePhase }[];
+  intake: string | undefined;
+  lastStop: DaemonStop | undefined;
+  siblings: { project: string; live: number }[];
+};
+
+/** Collects the complete status payload once for both text and JSON renderers. */
+export async function collectFleetStatus(projectName?: string): Promise<FleetStatusReport> {
+  const snapshot = statusSnapshot(projectName);
   const layers = fleetLayers(projectName);
   const project = findProject(loadConfig(), projectName);
   const rec = livingDaemon();
@@ -1325,7 +1416,7 @@ export async function renderStatus(projectName?: string): Promise<string> {
     // Read here rather than in `statusSnapshot`, which is synchronous and used
     // by callers that must not shell out. An unmetered project never spawns
     // the provider at all.
-    readPlanUsage(s.caps.planUsage, sharedUsageSource()),
+    readPlanUsage(snapshot.caps.planUsage, sharedUsageSource()),
     // Same reasoning as `planUsage`: the snapshot is synchronous, this read is
     // a shell-out, and undefined on any failure — one missing row, never a
     // broken report (#188).
@@ -1347,7 +1438,9 @@ export async function renderStatus(projectName?: string): Promise<string> {
   const healthBody = projectHealth.kind === "ok" ? rawHealth?.body : undefined;
   const cached = codeGraphFromHealthz(healthBody, project.name);
   const codeGraph = cached ?? (await probeCodeGraph(project));
-  const workerPhases = workerPhasesFromHealthz(healthBody, project.name);
+  const workerPhases = [...workerPhasesFromHealthz(healthBody, project.name)].map(
+    ([issue, phase]) => ({ issue, phase }),
+  );
   // The newest host-wide stop/restart provenance (#378). Read here — not in
   // `statusSnapshot`, which is synchronous and belongs to the daemon module —
   // and rendered identically from either project: the daemon_stops table is
@@ -1359,32 +1452,54 @@ export async function renderStatus(projectName?: string): Promise<string> {
   try {
     lastStop = store.latestDaemonStop();
     // Shared-daemon visibility (#545): every configured project other than the
-    // one being viewed, with its live-run count. Read from the same open store
-    // as the provenance above, so a status reader can tell "my fleet is idle"
-    // from "the process I am about to stop is busy".
+    // one being viewed, with its live-run count.
     siblings = loadConfig()
       .projects.filter((p) => p.name !== project.name)
       .map((p) => ({ project: p.name, live: store.liveRuns(p.name).length }));
   } finally {
     store.close();
   }
-  return formatFleetStatus(
-    { ...s, planUsage, github },
+  return {
+    ...snapshot,
+    planUsage,
+    github,
+    observedAt: Date.now(),
     layers,
     daemon,
     telegram,
-    Date.now(),
     codeGraph,
-    briefStatusLine(project),
-    decisionStatusLine(project.name),
-    failureClassBlock(project.name),
+    brief: briefStatusLine(project),
+    decisions: decisionStatusLine(project.name),
+    failureClasses: failureClassBlock(project.name),
     workerPhases,
-    intakeStatusLine(project.name),
+    intake: intakeStatusLine(project.name),
     lastStop,
     siblings,
+  };
+}
+
+export function renderFleetStatusReport(report: FleetStatusReport): string {
+  return formatFleetStatus(
+    report,
+    report.layers,
+    report.daemon,
+    report.telegram,
+    report.observedAt,
+    report.codeGraph,
+    report.brief,
+    report.decisions,
+    report.failureClasses,
+    new Map(report.workerPhases.map(({ issue, phase }) => [issue, phase])),
+    report.intake,
+    report.lastStop,
+    report.siblings,
   );
 }
 
+export async function renderStatus(projectName?: string): Promise<string> {
+  return renderFleetStatusReport(await collectFleetStatus(projectName));
+}
+
 /**
  * One line naming the brief layout, or nothing when it cannot be read.
  *
@@ -1692,6 +1807,68 @@ function makeChallengeCode(): string {
   return `FLEET-${hex}`;
 }
 
+/**
+ * The one armed-marker write both proofs share: same content, same mode, and
+ * the same restamp of the pre-per-project shared marker the heartbeat still
+ * honours — a project that just armed must not leave the bare marker around to
+ * re-arm future fleets through `disarm` (#316).
+ */
+function writeArmedMarker(path: string, owner: string, arm: ArmState): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `armed ${new Date().toISOString()} owner=${owner}\n`, { mode: 0o600 });
+  if (arm.legacy === "honoured") rmSync(legacyArmedMarkerPath(), { force: true });
+}
+
+/**
+ * The verdict's view of the session surface: the same dirs a challenge would
+ * watch, minus the transcript throw. An outside-tree claim is not a reason to
+ * stop here — the claim-only verdict names that failure itself
+ * (`claim-session-outside` / `dm-owner-unrelated`) with the same session
+ * identity rules, so the refusal carries the fact, not an early transcript
+ * wording.
+ */
+function armVerdictScanDirs(cwd: string, claimed: string | undefined): string[] {
+  const cwdDir = sessionDirForCwd(cwd);
+  if (claimed === undefined) return [cwdDir];
+  const root = sessionsRoot();
+  const claimDir = dirname(claimed);
+  if (claimDir === cwdDir) return [cwdDir];
+  const insideTree = claimDir === root || claimDir.startsWith(join(root, sep));
+  return insideTree ? [cwdDir, claimDir] : [cwdDir];
+}
+
+/**
+ * What each claim-only refusal names, in the operator's words (#613). The
+ * verdict's reason enum is the fact; this is the sentence that says it — the
+ * same facts the doctor's `telegram-plumbing` finding spells out, without the
+ * finding's remediation (the refusal is one line an unattended recovery can
+ * escalate verbatim).
+ */
+function claimOnlyFailureText(reason: TelegramPlumbingFailureReason): string {
+  switch (reason) {
+    case "channel-down":
+      return "the paired inbound channel is not up";
+    case "registry-unreadable":
+      return "omp-telegram's threads.json is absent, unreadable or malformed — the topic's claim liveness cannot be verified";
+    case "no-topic-claim":
+      return "no live omp-telegram claim carries the topic arming would send into";
+    case "claim-dead":
+      return "the topic's omp-telegram claim records no live pid — the pane behind it is gone";
+    case "claim-session-outside":
+      return "the topic's claim names a session file outside the session directories arm scans — the reply could never be seen";
+    case "no-dm-owner":
+      return "no flat-chat reply recipient: no dm-owner.json, and bot.lock names no session inside the arm scan surface";
+    case "dm-owner-dead":
+      return "omp-telegram's dm-owner.json records no live pid — the flat-chat recipient is gone";
+    case "dm-owner-unrelated":
+      return "the dm-owner.json session sits outside the arm scan surface — a flat reply would land where no challenge can read it";
+    case "no-poller-state":
+      return "omp-telegram's bot.lock is absent, unreadable or malformed — nothing owns the poll, so nothing is receiving inbound";
+    case "poller-dead":
+      return "omp-telegram's bot.lock records no live owner and no fresh heartbeat — Telegram isn't being polled";
+  }
+}
+
 async function sendTelegramMessage(
   token: string,
   owner: string,

package/src/gitops.ts

@@ -127,62 +127,141 @@ export interface RunLaneInput {
 }
 
 /**
- * The set of file paths one active run has touched relative to base, deduped
- * and sorted. Persistable but advisory: the admitting gate treats an unreadable
- * or absent lane as "no overlap" (fail open), so no probe bug can refuse a
- * well-formed issue.
+ * One file a run's lane covers, tagged with the probe read that produced it.
+ * The source is what lets a `file-lane` hold say *which* occupancy it is — the
+ * run's live worktree (`"worktree"`: uncommitted authored changes, from the
+ * porcelain read) or its committed work (`"branch"`: the base-relative diff,
+ * worktree or mirror) — so "held by run #N" can be told apart from the
+ * base-reconciliation noise #684 filters out entirely.
  */
-export type RunLaneProbe = (input: RunLaneInput) => Promise<string[]>;
+export interface LaneFile {
+  file: string;
+  source: LaneSource;
+}
+
+/** Which of the probe's reads produced one occupied file. */
+export type LaneSource = "worktree" | "branch";
+
+/**
+ * The set of files one active run has touched relative to base, deduped and
+ * sorted, each tagged with the read that produced it. Persistable but
+ * advisory: the admitting gate treats an unreadable or absent lane as "no
+ * overlap" (fail open), so no probe bug can refuse a well-formed issue.
+ */
+export type RunLaneProbe = (input: RunLaneInput) => Promise<LaneFile[]>;
 
 /** The real one, reading the run's own worktree and/or the mirror branch. */
 export async function probeRunLane(
   input: RunLaneInput,
   exec: Exec = spawnCaptured,
-): Promise<string[]> {
-  const files = new Set<string>();
-  const add = (raw: string): void => {
-    for (const line of raw.split("\n")) {
-      const path = line.trim();
-      if (path !== "") files.add(path);
-    }
+): Promise<LaneFile[]> {
+  const files = new Map<string, LaneSource>();
+  const add = (path: string, source: LaneSource): void => {
+    if (path !== "" && !files.has(path)) files.set(path, source);
+  };
+  const addDiff = (stdout: string, source: LaneSource): void => {
+    for (const line of stdout.split("\n")) add(line.trim(), source);
   };
   if (input.worktree !== "") {
     const status = await exec(["git", "-C", input.worktree, "status", "--porcelain"], {});
     if (status.code === 0) {
-      for (const path of parsePorcelain(status.stdout)) files.add(path);
+      const { untracked, tracked } = parsePorcelain(status.stdout);
+      // Untracked files are authored by construction: a merge stages the files
+      // it brings in, it never leaves them untracked.
+      for (const path of untracked) add(path, "worktree");
+      if (tracked.length > 0) {
+        // While a merge of the base is in progress — the reconciliation every
+        // continuation brief requires — the porcelain read reports every file
+        // the merge staged, which is every file the base changed since the
+        // branch's merge-base, none of them the run's own work (#684). The
+        // three-dot diff is immune (merge-base relative), so the porcelain
+        // half is gated on a live MERGE_HEAD and filtered to files whose
+        // worktree content has actually diverged from base: reconciliation
+        // brings base content forward (worktree == base), authored work does
+        // not. Unresolved conflicts were already excluded by
+        // {@link parsePorcelain}: a conflicted file is not the run's
+        // resolution. An unreadable divergence read fails open — no tracked
+        // occupancy is claimed while the merge makes the read ambiguous.
+        const merge = await exec(
+          ["git", "-C", input.worktree, "rev-parse", "-q", "--verify", "MERGE_HEAD"],
+          {},
+        );
+        if (merge.code === 0) {
+          const diverged = await exec(
+            ["git", "-C", input.worktree, "diff", "--name-only", input.baseRef],
+            {},
+          );
+          if (diverged.code === 0) {
+            const set = new Set(
+              diverged.stdout.split("\n").map((line) => line.trim()).filter((line) => line !== ""),
+            );
+            for (const path of tracked) if (set.has(path)) add(path, "worktree");
+          }
+        } else {
+          for (const path of tracked) add(path, "worktree");
+        }
+      }
     }
     const diff = await exec(
       ["git", "-C", input.worktree, "diff", "--name-only", `${input.baseRef}...HEAD`],
       {},
     );
-    if (diff.code === 0) add(diff.stdout);
+    if (diff.code === 0) addDiff(diff.stdout, "branch");
   }
   if (input.branchRef !== undefined && input.mirror !== undefined && input.mirror !== "") {
     const diff = await exec(
       ["git", "--git-dir", input.mirror, "diff", "--name-only", `${input.baseRef}...${input.branchRef}`],
       {},
     );
-    if (diff.code === 0) add(diff.stdout);
+    if (diff.code === 0) addDiff(diff.stdout, "branch");
   }
-  return [...files].sort();
+  return [...files.entries()]
+    .map(([file, source]) => ({ file, source }))
+    .sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
 }
 
 /**
- * Parse `git status --porcelain` output into the paths it names. A rename or
- * copy is reported as `XY old -> new`, and the *new* path is the one that
- * occupies the lane (it is the path the other run's future writes would
- * collide with), so the arrow form keeps only its target.
+ * The porcelain codes `git status --porcelain` emits for an unmerged index
+ * entry — a merge/rebase/cherry-pick conflict. The X/Y letters are then the
+ * stage-2/stage-3 states and only ever appear in this exact set (git-status(1)
+ * lists them all), so membership is unambiguous.
+ */
+const UNMERGED_PORCELAIN: Record<string, true> = {
+  UU: true,
+  AA: true,
+  DD: true,
+  AU: true,
+  UA: true,
+  DU: true,
+  UD: true,
+};
+
+/**
+ * Parse `git status --porcelain` output into the paths it names, split by how
+ * they may occupy a lane. A rename or copy is reported as `XY old -> new`, and
+ * the *new* path is the one that occupies the lane (it is the path the other
+ * run's future writes would collide with), so the arrow form keeps only its
+ * target. Untracked (`??`) paths are always the run's own work. Unmerged
+ * (`UU`-class) paths are dropped: a conflicted file is not the run's
+ * resolution, so it neither occupies a lane nor proves authorship.
  */
-function parsePorcelain(stdout: string): string[] {
-  const out = new Set<string>();
+function parsePorcelain(stdout: string): { untracked: string[]; tracked: string[] } {
+  const untracked: string[] = [];
+  const tracked: string[] = [];
   for (const raw of stdout.split("\n")) {
     if (raw.length < 3) continue;
+    const code = raw.slice(0, 2);
+    if (code === "??") {
+      untracked.push(raw.slice(2).trim());
+      continue;
+    }
+    if (UNMERGED_PORCELAIN[code] === true) continue;
     let rest = raw.slice(2).trim();
     const arrow = rest.indexOf(" -> ");
     if (arrow !== -1) rest = rest.slice(arrow + 4).trim();
-    if (rest !== "") out.add(rest);
+    if (rest !== "") tracked.push(rest);
   }
-  return [...out];
+  return { untracked, tracked };
 }
 
 /** GitHub slug parsed off the clone URL, falling back to the routing name. */