@ordewell/core 0.10.8 → 0.10.9

package/dist/index.js

@@ -10811,6 +10811,8 @@ var RunnerProcess = class {
   markEnded;
   child = null;
   exitStatus = null;
+  /** The process itself reported its end, before its pipes drained; see {@link hasExited}. */
+  exitReported = false;
   stderrTail = "";
   spawnEnv = {};
   /** Stdout readers' end-of-stream flushes, for an end the pipe itself never reports. */
@@ -10861,6 +10863,7 @@ var RunnerProcess = class {
     });
     child.on("close", (code, signal) => this.end({ code, signal }));
     child.once("exit", (code, signal) => {
+      this.exitReported = true;
       const grace = setTimeout(() => {
         for (const flush of [...this.stdoutEnds]) flush();
         this.end({ code, signal });
@@ -10915,6 +10918,15 @@ ${err.message}`);
   get exit() {
     return this.exitStatus;
   }
+  /**
+   * Whether the process has ended, for any reason. Unlike {@link exit} this is
+   * true from its own 'exit', not only once 'close' has drained the pipes: a
+   * runner that has exited can take no further turn even while a descendant
+   * holds its stdout or stderr.
+   */
+  get hasExited() {
+    return this.exitStatus !== null || this.exitReported;
+  }
   /** The exit code a listener is told: -1 for a signal or a spawn failure. */
   get exitCode() {
     return this.exitStatus?.code ?? -1;
@@ -11113,6 +11125,9 @@ var StdioAgentAdapter = class {
   nativeSessionId() {
     return this.sessionId;
   }
+  get exited() {
+    return this.runner.hasExited;
+  }
   onProcessExit(listener) {
     const fire = () => listener(this.runner.exitCode, this.exitMessage());
     if (this.runner.exit) queueMicrotask(fire);
@@ -14926,7 +14941,7 @@ var OpenCodeAdapter = class {
     return this.runner.ended;
   }
   get exited() {
-    return this.runner.exit !== null;
+    return this.runner.hasExited;
   }
   async start(opts) {
     try {
@@ -23103,10 +23118,21 @@ var GitWorktreeIsolation = class {
       const entry = record.repos[repo.path];
       if (!entry?.changed) continue;
       const merged = await this.tryGit(repo.root, ["merge-base", "--is-ancestor", entry.landedTip ?? repo.integrationBranch, "HEAD"]);
-      if (!merged.ok) return false;
+      if (!merged.ok && !await this.integrationGone(repo)) return false;
     }
     return true;
   }
+  /**
+   * The repo's integration branch is gone — deleted by hand, or by a squash
+   * merge's clean-up — in a repo git can read. Merge all merges that branch by
+   * name, so no merge can bring the work in again, and it is not offered as
+   * work to merge. A repo git cannot read at all (moved, or git failing)
+   * proves nothing either way and counts as not merged.
+   */
+  async integrationGone(repo) {
+    if (!(await this.tryGit(repo.root, ["rev-parse", "--verify", "-q", "HEAD"])).ok) return false;
+    return !(await this.tryGit(repo.root, ["rev-parse", "--verify", "-q", `refs/heads/${repo.integrationBranch}`])).ok;
+  }
   async snapshotTree(workspaceRoot, exclude) {
     const scan = await this.scanGroup(workspaceRoot);
     if ("refused" in scan) return null;
@@ -26321,6 +26347,8 @@ var IsolationRunController = class {
   listener;
   liveTasks;
   run = null;
+  /** An adoption stays scoped even while cleanup temporarily leaves no run record. */
+  adoptions = 0;
   /** Copied paths already reported for the current run: every task gets the same copies. */
   reportedCopies = /* @__PURE__ */ new Set();
   reportedSetupFailures = /* @__PURE__ */ new Set();
@@ -26396,18 +26424,27 @@ var IsolationRunController = class {
    * Take over a plan's persisted isolation, or none for a plan that has not
    * isolated yet. Whatever a crashed process left behind for the run — a
    * worktree still marked active, a directory no record owns — is pruned,
-   * while kept, failed and conflicted worktrees stay for the user.
+   * while kept, failed and conflicted worktrees stay for the user. Then git is
+   * asked which landed work the user has merged since the record was saved:
+   * a settled run whose landed work is all in HEAD has nothing left to hand
+   * over, so it is cleared up as Merge all would have, unless it still holds
+   * work that never landed (ADR-0013).
    *
-   * Deliberately not reported as a change: adopting is not a change to
-   * persist, and a host that adopts without persisting (VS Code's restore)
-   * would otherwise write a new session file on every reload.
+   * Deliberately not reported to the listener: adopting is not a change of the
+   * session's own, and a host that adopts without persisting (VS Code's
+   * restore) would otherwise write a new session file on every reload. What
+   * git changed is returned instead, for the caller to save where it can and
+   * announce. A plan loaded meanwhile supersedes this adoption, which then
+   * touches nothing and resolves `unchanged`.
    */
   async adopt(state) {
+    const adoption = ++this.adoptions;
     this.run = state?.run ?? null;
     this.resolvers = { ...state?.resolvers ?? {} };
-    if (!this.run) return;
+    const run = this.run;
+    if (!run) return "unchanged";
     try {
-      const pruned = await this.isolation.pruneOrphans(this.run);
+      const pruned = await this.isolation.pruneOrphans(run);
       for (const task of pruned.kept) {
         this.tell("warn", `Task "${task.title}" was still holding unlanded work when this plan was re-opened, so its worktree and branch were kept. Retry it to land the work, or review it by hand.`);
       }
@@ -26415,6 +26452,24 @@ var IsolationRunController = class {
     } catch (err) {
       this.tell("warn", `Could not prune leftover worktrees: ${err instanceof Error ? err.message : String(err)}`);
     }
+    if (this.run !== run) return "unchanged";
+    const found = await this.findLanded(run);
+    if (this.run !== run) return "unchanged";
+    const outcome = found ? "changed" : "unchanged";
+    if (this.isOpen || !this.allMerged(run) || this.holdouts(run).length > 0) return outcome;
+    const resolvers = this.resolvers;
+    this.run = null;
+    this.resolvers = {};
+    const discarded = await this.discardMerged(run);
+    if (this.adoptions !== adoption) return "unchanged";
+    if (!discarded) {
+      if (this.run === null) {
+        this.run = run;
+        this.resolvers = resolvers;
+      }
+      return outcome;
+    }
+    return this.isOpen ? "changed" : "cleared";
   }
   /** Open a run if none is, leaving whether it isolates to its first change task. */
   open() {
@@ -26571,8 +26626,7 @@ var IsolationRunController = class {
     const run = this.run;
     if (mode !== "isolated" || !run) return;
     await this.refreshInHead();
-    const records = Object.values(run.tasks);
-    if (records.some((r) => r.status === "merged") && handoffOf(run).landed.length === 0) {
+    if (this.allMerged(run)) {
       this.tell("info", "Everything this run landed is merged into your branch already.");
       await this.clearMerged(run);
       return;
@@ -26599,11 +26653,21 @@ var IsolationRunController = class {
    */
   async refreshInHead() {
     const run = this.run;
-    if (!run || !Object.values(run.tasks).some((r) => r.status === "merged" && !r.inHead)) return false;
+    if (!run) return false;
+    const found = await this.findLanded(run);
+    if (found) this.listener.changed();
+    return found;
+  }
+  /** Mark the run's landed work git finds in HEAD; true when some was found. */
+  async findLanded(run) {
+    if (!Object.values(run.tasks).some((r) => r.status === "merged" && !r.inHead)) return false;
     const found = await this.isolation.findInHead(run).catch(() => []);
-    if (found.length > 0) this.listener.changed();
     return found.length > 0;
   }
+  /** The run landed something and every landing is in the user's HEAD. */
+  allMerged(run) {
+    return Object.values(run.tasks).some((r) => r.status === "merged") && handoffOf(run).landed.length === 0;
+  }
   /**
    * The tracked state of the workspace as an attempt whose tree is checked
    * starts (see `attemptKind.checksTree`), for {@link filesChangedSince}
@@ -26725,7 +26789,7 @@ var IsolationRunController = class {
    */
   async clearMerged(run) {
     const live2 = this.liveRecords(run);
-    const unlanded = Object.values(run.tasks).filter((r) => r.status !== "merged" && !live2.includes(r));
+    const unlanded = this.holdouts(run).filter((r) => !live2.includes(r));
     if (live2.length > 0 || unlanded.length > 0) {
       const why = [
         ...live2.length > 0 ? [`${tasksNamed(live2)} ${live2.length === 1 ? "is" : "are"} still running or waiting on you`] : [],
@@ -26735,13 +26799,22 @@ var IsolationRunController = class {
       this.tell("info", `The run is not cleared up: ${why.join(", and ")}, so ${one ? "its worktree stays" : "their worktrees stay"}, and so do the run's branches.`);
       return;
     }
+    if (await this.discardMerged(run)) this.forget();
+  }
+  /** The records that keep a settled run from being cleared up: live, or holding work that never landed. */
+  holdouts(run) {
+    const live2 = this.liveTasks();
+    return Object.values(run.tasks).filter((r) => live2.has(r.taskId) || r.status !== "merged");
+  }
+  /** The run's worktrees and merged branches go; false, said, when git would not let them. */
+  async discardMerged(run) {
     try {
       this.report(await this.isolation.discard(run, { integration: "delete-merged" }));
+      return true;
     } catch (err) {
       this.tell("warn", `Merged, but could not clean up the run's worktrees and branches: ${err instanceof Error ? err.message : String(err)}`);
-      return;
+      return false;
     }
-    this.forget();
   }
   /** Say what a removal kept back instead of deleting: where the work went, or which worktree stayed. */
   report(removal) {
@@ -30396,17 +30469,37 @@ var CliAgentAiService = class {
    * `startConversation` reseeds from Ordewell's transcript, which is the same
    * degradation `restoreChat` already performs on every surface.
    *
+   * A process can end while idle without Ordewell stopping it — the OS, the
+   * CLI itself, a sleeping machine, a signal sent to its group — and every
+   * path of ours that kills one also drops its adapter. So an adapter still
+   * held whose process has ended died on its own, and is restarted here
+   * rather than answering the next message with its exit code.
+   *
    * Also restarted when the policy's decision on the runner's own search has
    * changed since the process was spawned: the running thread would otherwise
    * keep searching unasked after Full turned Guarded. Codex 0.162 applies
    * `thread/resume`'s `config.web_search` either way (checked live).
    */
   async ensureAdapter(session) {
-    if (session.adapter && session.nativeSearch === this.nativeSearch(session)) return session.adapter;
+    const live2 = session.adapter;
+    if (live2 && !live2.exited && session.nativeSearch === this.nativeSearch(session)) return live2;
     session.stop();
     const start = session.start;
     if (!start) throw new Error("No active planner conversation.");
-    return this.startAdapter({ ...start.startOptions, resumeSessionId: session.nativeSessionId ?? void 0, resumeCost: session.sessionCost ?? void 0 }, start.tools, session);
+    const resumeSessionId = session.nativeSessionId ?? void 0;
+    try {
+      const adapter = await this.startAdapter({ ...start.startOptions, resumeSessionId, resumeCost: session.sessionCost ?? void 0 }, start.tools, session);
+      const resumed = adapter.nativeSessionId();
+      if (resumeSessionId && resumed && resumed !== resumeSessionId) {
+        throw new Error("The runner started a different session instead.");
+      }
+      return adapter;
+    } catch (err) {
+      if (!resumeSessionId || session.discarded.aborted) throw err;
+      if (this.session === session) this.session = null;
+      session.discard();
+      throw new Error(`The ${this.runner} planner's session could not be resumed (${err instanceof Error ? err.message : String(err)}). Send your message again: the planner picks the conversation up from its transcript.`);
+    }
   }
   /**
    * What the planner gets of the repository's config, its runner being
@@ -31532,6 +31625,12 @@ function withoutIsolation(tasks) {
 function handoffOf2({ type: _type, ...handoff }) {
   return handoff;
 }
+function stillToMerge(handoff, runMerge) {
+  if (!handoff?.landed.length) return handoff;
+  if (!runMerge) return null;
+  const same = runMerge.landed.length === handoff.landed.length && runMerge.landed.every((t, i) => t.taskId === handoff.landed[i].taskId);
+  return same ? handoff : { ...handoff, repos: runMerge.repos, landed: runMerge.landed };
+}
 function planTasks(plan) {
   if ("tasks" in plan) return plan.tasks;
   return rejoinPlanTree(plan.pendingTasks, plan.phase === "executing" ? plan.executionLog : []);
@@ -31552,6 +31651,7 @@ function reduceRun(view, input) {
         ...view,
         tasks: applyStatus(view.tasks, new Map(input.tasks.map((t) => [t.id, t]))),
         runMerge: input.runMerge ?? null,
+        handoff: stillToMerge(view.handoff, input.runMerge),
         usage: input.usage
       };
     case "task_started":
@@ -35035,9 +35135,9 @@ var Session = class {
   runSnapshot() {
     if (!this.plan) return EMPTY_RUN;
     const planned = reduceRun(EMPTY_RUN, { type: "plan_snapshot", plan: surfacePlan({ ...this.plan, tasks: this.store.snapshot() }) });
-    const view = reduceRun(planned, this.events.statusMessage());
-    const held2 = this.sentHeld ? reduceRun(view, { type: "plan_edit_held", held: this.sentHeld }) : view;
-    return this.sentHandoff ? reduceRun(held2, { type: "isolation_handoff", ...this.sentHandoff }) : held2;
+    const handed = this.sentHandoff ? reduceRun(planned, { type: "isolation_handoff", ...this.sentHandoff }) : planned;
+    const view = reduceRun(handed, this.events.statusMessage());
+    return this.sentHeld ? reduceRun(view, { type: "plan_edit_held", held: this.sentHeld }) : view;
   }
   /** The ancestors a task waits on at its merge gate (ADR-0020); empty when it waits for no Merge all. */
   mergeGate(taskId) {
@@ -35227,12 +35327,31 @@ var Session = class {
     }
     carryOverQueuedEdits(plan);
     if (adopting) {
-      void this.runs.adopt(plan.isolation ?? null);
+      void this.adoptRun(plan, opts?.persist !== false || opts?.sessionId !== void 0);
       this.sentHandoff = this.owedHandoff();
     }
     if (opts?.persist !== false) this.persist();
     if (this.usage.hasUsage) this.broadcast(this.usage.message());
   }
+  /**
+   * Take the loaded plan's run over, then correct what the surfaces were told
+   * by what git found: the saved record cannot know what the user merged
+   * since, and its handoff would offer Merge all for work already in their
+   * branch. The status update says what landed work is still unmerged, which
+   * a handoff folds to (see `reduceRun`), and `run_closed` that the run was
+   * cleared up. Saved only where the load itself may save (`persists`), so a
+   * restore with no session file to write keeps the correction in memory for
+   * its next save. A plan loaded meanwhile is not this one's to correct.
+   * Starts nothing (ADR-0044).
+   */
+  async adoptRun(plan, persists) {
+    const outcome = await this.runs.adopt(plan.isolation ?? null);
+    if (this.closed || this.plan !== plan || outcome === "unchanged") return;
+    plan.isolation = this.runs.planIsolation ?? void 0;
+    if (persists) this.persist();
+    this.events.status(plan);
+    if (outcome === "cleared") this.broadcast({ type: "run_closed" });
+  }
   destroy() {
     this.closed = true;
     this.dropPlanScope();
@@ -36810,11 +36929,13 @@ var STATE_FILE = "state.json";
 function getStatePath(baseDir) {
   return path34.join(getStateDir(baseDir), STATE_FILE);
 }
-function saveState(plan, baseDir) {
+var SESSION_ID_KEY = "sessionId";
+function saveState(plan, baseDir, sessionId) {
   const statePath = getStatePath(baseDir ?? process.cwd());
   ensureDir(path34.dirname(statePath));
   plan.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-  fs17.writeFileSync(statePath, JSON.stringify(plan, null, 2));
+  const file = sessionId ? { ...plan, [SESSION_ID_KEY]: sessionId } : plan;
+  fs17.writeFileSync(statePath, JSON.stringify(file, null, 2));
 }
 function loadState(baseDir, logger = defaultLogger) {
   const dir = baseDir ?? process.cwd();
@@ -36827,10 +36948,12 @@ function loadState(baseDir, logger = defaultLogger) {
       logger.warn("stateStore", `rejecting state from ${statePath}: old format (scalar "runner" instead of "runners" array). Please re-plan.`);
       return null;
     }
+    const sessionId = parsed[SESSION_ID_KEY];
+    delete parsed[SESSION_ID_KEY];
     const plan = parsed;
     migratePlanStateIsolation(plan);
     migrateLoadedTasks(plan.tasks);
-    return plan;
+    return typeof sessionId === "string" && sessionId ? { plan, sessionId } : { plan };
   } catch (err) {
     logger.warn("stateStore", `failed to load state from ${statePath}; falling back to empty state`, err);
     return null;