@ordewell/core 0.11.3 → 0.12.0

package/dist/{chunk-QTZ5XTBY.mjs → chunk-F6WS3JLQ.mjs}

@@ -146,7 +146,16 @@ var isKnownStatus = (status) => Object.prototype.hasOwnProperty.call(ISOLATION_S
 function changedReposOf(record) {
   return Object.entries(record.repos).filter(([, r]) => r.changed).map(([repoPath]) => repoPath);
 }
-function taskIsolationOf(record, repairLimit) {
+function landedInRepo(run, record, repoPath) {
+  return !!record.repos[repoPath]?.changed || run.landings?.[record.taskId]?.[repoPath] !== void 0;
+}
+function revertible(record, run) {
+  if (record.inHead || record.status === "active" || record.status === "repairing" || !run?.carried || run.carried[record.taskId]) return false;
+  const landings = run?.landings?.[record.taskId];
+  const changed = record.status === "merged" ? changedReposOf(record) : [];
+  return (changed.length > 0 || landings !== void 0) && changed.every((repo) => record.repos[repo].landedTip || landings?.[repo]);
+}
+function taskIsolationOf(record, repairLimit, run) {
   return {
     state: ISOLATION_STATE[record.status],
     branch: record.branch,
@@ -155,9 +164,20 @@ function taskIsolationOf(record, repairLimit) {
     ...record.conflictRepo ? { conflictRepo: record.conflictRepo } : {},
     ...record.conflictFiles?.length ? { conflictFiles: record.conflictFiles } : {},
     ...record.repairs && repairLimit !== void 0 ? { repair: { attempt: record.repairs, limit: repairLimit } } : {},
-    ...record.repairedFiles?.length ? { repairedFiles: record.repairedFiles } : {}
+    ...record.repairedFiles?.length ? { repairedFiles: record.repairedFiles } : {},
+    ...revertible(record, run) ? { revertible: true } : {}
   };
 }
+function taskIsolationsOf(run, repairLimit) {
+  const tasks = {};
+  for (const taskId of Object.keys(run.landings ?? {})) {
+    if (run.carried && !run.carried[taskId]) tasks[taskId] = { state: "none", revertible: true };
+  }
+  for (const [taskId, record] of Object.entries(run.tasks)) {
+    if (isKnownStatus(record.status)) tasks[taskId] = taskIsolationOf(record, repairLimit, run);
+  }
+  return tasks;
+}
 function handoffOf(run) {
   const merged = Object.values(run.tasks).filter((r) => r.status === "merged" && !r.inHead).sort((a, b) => a.order - b.order);
   const entry = (r) => ({
@@ -173,7 +193,7 @@ function handoffOf(run) {
       baseRef: repo.baseRef,
       ...repo.baseBranch ? { baseBranch: repo.baseBranch } : {},
       ...repo.startedDetached ? { startedDetached: true } : {},
-      landed: merged.filter((r) => r.repos[repo.path]?.changed).map(entry)
+      landed: merged.filter((r) => landedInRepo(run, r, repo.path)).map(entry)
     })),
     landed: merged.map(entry)
   };
@@ -225,12 +245,396 @@ function carriesIsolation(plan) {
 function isolationViewOfPlan(plan, repairLimit) {
   if (!carriesIsolation(plan)) return null;
   const { run } = migratePlanIsolation(plan.isolation);
-  const tasks = {};
-  for (const [taskId, record] of Object.entries(run.tasks)) {
-    if (!isKnownStatus(record.status)) continue;
-    tasks[taskId] = taskIsolationOf(record, repairLimit);
+  return { tasks: taskIsolationsOf(run, repairLimit), handoff: handoffOf(run) };
+}
+
+// src/services/VerdictEngine.ts
+var IDLE_TIMEOUT_MS = 10 * 6e4;
+var VerdictEngine = class {
+  pendingVerdicts = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  listeners = [];
+  checkpointListeners = [];
+  withdrawnListeners = [];
+  /** The open `checkpoint` tool call per task (ADR-0022, V5): settling it is how an answer reaches the runner. */
+  toolCheckpoints = /* @__PURE__ */ new Map();
+  /** The question a task's checkpoint asks, whole, for as long as it waits. */
+  checkpointQuestions = /* @__PURE__ */ new Map();
+  idleListeners = [];
+  /**
+   * Per-task generation. Replaced on every watch(), clear() and verdict.
+   * Stale callbacks (from a prior session whose generation doesn't match
+   * the current one) bail out instead of delivering a verdict for the
+   * wrong session.
+   */
+  generations = /* @__PURE__ */ new Map();
+  /**
+   * Generations come from one counter that {@link reset} never rewinds: a
+   * per-task count restarted at 1 after a reset, and the next watch handed a
+   * session that outlived the reset the same generation as its successor.
+   */
+  lastGeneration = 0;
+  idleTimers = /* @__PURE__ */ new Map();
+  idleSince = /* @__PURE__ */ new Map();
+  /** Tasks waiting on the user, whose silence is expected rather than a sign of a stuck runner. */
+  idlePaused = /* @__PURE__ */ new Set();
+  /**
+   * Open tool approvals per structured task. They arrive mid-turn and leave the
+   * status alone (ADR-0018, W1), but a task waiting on one is waiting on the
+   * user, so it is not idle either.
+   */
+  openApprovals = /* @__PURE__ */ new Map();
+  onVerdict(listener) {
+    this.listeners.push(listener);
+  }
+  onCheckpoint(listener) {
+    this.checkpointListeners.push(listener);
+  }
+  onCheckpointWithdrawn(listener) {
+    this.withdrawnListeners.push(listener);
+  }
+  onIdleChange(listener) {
+    this.idleListeners.push(listener);
+  }
+  /** Advisory silence timestamp for a task, or null if it isn't idle. */
+  getIdleSince(taskId) {
+    return this.idleSince.get(taskId) ?? null;
+  }
+  /**
+   * Stop watching a task's silence while it waits on the user (ADR-0018, W1).
+   * Watching resumes when its next turn starts, or when a checkpoint is answered.
+   */
+  pauseIdle(taskId) {
+    this.idlePaused.add(taskId);
+    this.clearIdle(taskId);
+  }
+  resumeIdle(taskId) {
+    const gen = this.generations.get(taskId);
+    if (!this.idlePaused.delete(taskId) || gen === void 0) return;
+    this.touchIdle(taskId, gen);
+  }
+  /** Restart the silence timer on fresh output; broadcasts the null transition if it was idle. */
+  touchIdle(taskId, gen) {
+    if (this.idlePaused.has(taskId) || this.openApprovals.get(taskId)?.size) return;
+    const existing = this.idleTimers.get(taskId);
+    if (existing) clearTimeout(existing);
+    if (this.idleSince.get(taskId)) {
+      this.idleSince.set(taskId, null);
+      for (const l of this.idleListeners) l(taskId, null);
+    }
+    this.idleTimers.set(taskId, setTimeout(() => {
+      if (this.generations.get(taskId) !== gen) return;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      this.idleSince.set(taskId, now);
+      for (const l of this.idleListeners) l(taskId, now);
+    }, IDLE_TIMEOUT_MS));
+  }
+  /** Tear down idle tracking for a task; broadcasts the null transition if it was idle. */
+  clearIdle(taskId) {
+    const timer = this.idleTimers.get(taskId);
+    if (timer) clearTimeout(timer);
+    this.idleTimers.delete(taskId);
+    const wasIdle = this.idleSince.get(taskId);
+    this.idleSince.delete(taskId);
+    if (wasIdle) {
+      for (const l of this.idleListeners) l(taskId, null);
+    }
+  }
+  /** What a task's waiting checkpoint asks, untruncated; undefined when none waits. */
+  getCheckpointQuestion(taskId) {
+    return this.checkpointQuestions.get(taskId);
+  }
+  approveCheckpoint(taskId) {
+    this.checkpointQuestions.delete(taskId);
+    this.resumeIdle(taskId);
+    this.toolCheckpoints.get(taskId)?.({ kind: "continue" });
+  }
+  rejectCheckpoint(taskId, reason) {
+    this.checkpointQuestions.delete(taskId);
+    this.resumeIdle(taskId);
+    this.toolCheckpoints.get(taskId)?.({ kind: "rejected", reason });
+  }
+  /**
+   * An attempt's runner is being started, with no session to watch yet. Its
+   * silence counts from here, so one whose start never resolves — stuck
+   * launching, or waiting for its tools to attach — is flagged quiet as well.
+   * {@link watch} starts the count again once the runner is up.
+   */
+  starting(taskId) {
+    const gen = this.bumpGeneration(taskId);
+    this.idlePaused.delete(taskId);
+    this.openApprovals.delete(taskId);
+    this.touchIdle(taskId, gen);
+  }
+  /**
+   * Attach to a spawned session. The runner's `task_complete` call on the
+   * attempt's token is the only completion evidence (ADR-0022, V2); a session
+   * that exits before one gets a failed verdict. A script task's session has
+   * no runner to call it: its exit status is the evidence instead (ADR-0035).
+   *
+   * Returns the attempt's generation, what {@link signalComplete} is checked against.
+   */
+  watch(task, session) {
+    const gen = this.bumpGeneration(task.id);
+    this.idlePaused.delete(task.id);
+    this.openApprovals.delete(task.id);
+    this.touchIdle(task.id, gen);
+    session.onOutput(() => {
+      if (this.generations.get(task.id) === gen) this.touchIdle(task.id, gen);
+    });
+    this.sessions.set(task.id, session);
+    session.onTurnEnd(() => {
+      if (this.generations.get(task.id) !== gen) return;
+      this.callWentAway(task.id, "the turn it was asked in has ended.");
+      const pending = this.pendingVerdicts.get(task.id);
+      this.pendingVerdicts.delete(task.id);
+      if (session.turnState() === "idle" && pending) this.publishVerdict(task.id, pending);
+    });
+    session.onEvent((event) => {
+      if (this.generations.get(task.id) !== gen) return;
+      if (event.type === "turn_start") {
+        this.supersede(task.id);
+        this.resumeIdle(task.id);
+      } else if (event.type === "message_delivered") this.supersede(task.id);
+      else if (event.type === "permission_request" && !event.decided) this.approvalOpened(task.id, event.id);
+      else if (event.type === "permission_decided" || event.type === "permission_withdrawn") this.approvalClosed(task.id, event.id, gen);
+    });
+    session.onTaskComplete((report) => this.signalComplete(task.id, gen, report));
+    session.onScriptExit((exit) => this.signalScriptExit(task.id, gen, exit));
+    session.onToolCheckpoint((question, signal) => this.raiseCheckpoint(task.id, gen, question, signal));
+    session.onExit((exitCode) => {
+      if (this.generations.get(task.id) !== gen) return;
+      this.forget(task.id);
+      const verdict = exitVerdict(exitCode);
+      for (const l of this.listeners) l(task.id, verdict);
+    });
+    return gen;
+  }
+  /**
+   * The runner's own `task_complete` call (ADR-0022, V1/V3): settles the
+   * attempt, unless that attempt is no longer the task's current one or an
+   * earlier call already settled it.
+   */
+  signalComplete(taskId, generation, report) {
+    if (this.generations.get(taskId) !== generation) return;
+    this.acceptVerdict(taskId, reportedVerdict(report));
+  }
+  /**
+   * A script task's exit status (ADR-0035): its one evidence, as a runner's
+   * `task_complete` call is a runner's. It settles the attempt unless that
+   * attempt is no longer the task's current one.
+   */
+  signalScriptExit(taskId, generation, exit) {
+    if (this.generations.get(taskId) !== generation) return;
+    this.acceptVerdict(taskId, scriptVerdict(exit));
+  }
+  /** The runner was told something after its evidence so far, so only what it reports from here counts. */
+  supersede(taskId) {
+    this.pendingVerdicts.delete(taskId);
+  }
+  acceptVerdict(taskId, verdict) {
+    if (this.pendingVerdicts.has(taskId)) return;
+    if (this.sessions.get(taskId)?.queued().length) {
+      this.pendingVerdicts.set(taskId, verdict);
+      return;
+    }
+    this.publishVerdict(taskId, verdict);
+  }
+  publishVerdict(taskId, verdict) {
+    this.forget(taskId);
+    this.bumpGeneration(taskId);
+    for (const l of this.listeners) l(taskId, verdict);
+  }
+  /**
+   * The runner's `checkpoint` call (ADR-0022, V5): the task waits on the
+   * user until it is settled by {@link approveCheckpoint} or {@link rejectCheckpoint}. It is
+   * withdrawn, never left hanging, once the attempt is over or the call goes.
+   */
+  raiseCheckpoint(taskId, generation, question, signal) {
+    if (this.generations.get(taskId) !== generation || signal.aborted) {
+      return Promise.resolve({ kind: "withdrawn", why: "this attempt has ended." });
+    }
+    if (this.toolCheckpoints.has(taskId)) {
+      return Promise.resolve({ kind: "withdrawn", why: "another checkpoint is still waiting for an answer. Wait for it before asking again." });
+    }
+    return new Promise((resolve) => {
+      const settle = (answer) => {
+        signal.removeEventListener("abort", onAbort);
+        if (this.toolCheckpoints.get(taskId) === settle) {
+          this.toolCheckpoints.delete(taskId);
+          this.checkpointQuestions.delete(taskId);
+        }
+        resolve(answer);
+      };
+      const onAbort = () => {
+        settle({ kind: "withdrawn", why: "the call was cancelled." });
+        if (this.generations.get(taskId) !== generation) return;
+        this.resumeIdle(taskId);
+        for (const l of this.withdrawnListeners) l(taskId);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.toolCheckpoints.set(taskId, settle);
+      this.checkpointQuestions.set(taskId, question.trim());
+      for (const l of this.checkpointListeners) l(taskId, question.trim());
+    });
+  }
+  /** The open `checkpoint` call can no longer be answered: refuse it, and let the task out of the wait. */
+  callWentAway(taskId, why) {
+    const open = this.toolCheckpoints.get(taskId);
+    if (!open) return;
+    open({ kind: "withdrawn", why });
+    this.resumeIdle(taskId);
+    for (const l of this.withdrawnListeners) l(taskId);
+  }
+  withdrawToolCheckpoint(taskId) {
+    this.toolCheckpoints.get(taskId)?.({ kind: "withdrawn", why: "this attempt has ended." });
+  }
+  approvalOpened(taskId, approvalId) {
+    const open = this.openApprovals.get(taskId) ?? /* @__PURE__ */ new Set();
+    open.add(approvalId);
+    this.openApprovals.set(taskId, open);
+    this.clearIdle(taskId);
+  }
+  approvalClosed(taskId, approvalId, gen) {
+    const open = this.openApprovals.get(taskId);
+    if (!open?.delete(approvalId) || open.size) return;
+    this.openApprovals.delete(taskId);
+    this.touchIdle(taskId, gen);
+  }
+  bumpGeneration(taskId) {
+    this.lastGeneration += 1;
+    this.generations.set(taskId, this.lastGeneration);
+    return this.lastGeneration;
+  }
+  forget(taskId) {
+    this.pendingVerdicts.delete(taskId);
+    this.sessions.delete(taskId);
+    this.withdrawToolCheckpoint(taskId);
+    this.checkpointQuestions.delete(taskId);
+    this.idlePaused.delete(taskId);
+    this.openApprovals.delete(taskId);
+    this.clearIdle(taskId);
+  }
+  /** Manual "Mark complete" override: a pass verdict that bypasses evidence. */
+  markComplete(task) {
+    this.ceaseTracking(task.id);
+    return {
+      outcome: "pass",
+      reason: "Manually marked complete by user.",
+      checks: [
+        {
+          name: "manual",
+          passed: true,
+          skipped: false,
+          detail: "Task was manually marked complete by the user; no automatic verification was performed."
+        }
+      ],
+      decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Clear verification state for a task (used on retry). */
+  clear(task) {
+    this.ceaseTracking(task.id);
+  }
+  /** Drop a task's verification state and invalidate any callbacks still holding its generation. */
+  ceaseTracking(taskId) {
+    this.forget(taskId);
+    this.bumpGeneration(taskId);
+  }
+  /** Drop all tracking state (used on stop / loadPlan). */
+  reset() {
+    this.pendingVerdicts.clear();
+    this.sessions.clear();
+    for (const taskId of [...this.toolCheckpoints.keys()]) this.withdrawToolCheckpoint(taskId);
+    this.checkpointQuestions.clear();
+    for (const timer of this.idleTimers.values()) clearTimeout(timer);
+    this.idleTimers.clear();
+    this.idleSince.clear();
+    this.idlePaused.clear();
+    this.openApprovals.clear();
+    this.generations.clear();
+  }
+};
+var EXIT_CHECK = "exit_code";
+function endedByExit(verdict) {
+  return verdict.checks.some((check) => check.name === EXIT_CHECK);
+}
+function exitVerdict(exitCode) {
+  const normalized = exitCode == null ? 0 : exitCode;
+  const exitOk = normalized === 0;
+  return {
+    outcome: "fail",
+    reason: exitOk ? "Failed verification: the runner exited cleanly but never called task_complete." : `Failed verification: the runner exited with code ${normalized} without calling task_complete.`,
+    checks: [
+      { name: "task_complete", passed: false, skipped: false, detail: "the runner exited before calling task_complete" },
+      { name: EXIT_CHECK, passed: exitOk, skipped: false, detail: exitOk ? "the runner exited cleanly (code 0)" : `the runner exited with code ${normalized}` }
+    ],
+    decidedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function interruptedVerdict(decidedAt) {
+  return { outcome: "fail", reason: "It was interrupted when Ordewell stopped, and nothing is running it now.", checks: [], decidedAt };
+}
+function statusText(status) {
+  if (status.error !== void 0) return `could not start: ${status.error}`;
+  if (status.signal) return `was ended by ${status.signal}`;
+  return `exited with code ${status.code ?? "unknown"}`;
+}
+function withTail(reason, errorTail, fullOutput) {
+  const tail = errorTail.trim();
+  const quoted = tail ? `${reason}
+
+The end of its error output:
+${tail}` : reason;
+  if (!fullOutput) return quoted;
+  const cut = fullOutput.droppedChars > 0 ? `, except its last ${fullOutput.droppedChars} characters, which were not saved.` : "";
+  return `${quoted}
+
+All of its output is in ${fullOutput.file}${cut}`;
+}
+function scriptVerdict(exit) {
+  const decidedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const check = (passed, detail) => [{ name: "script_exit", passed, skipped: false, detail }];
+  const command = exit.outcome !== "passed" && exit.command !== void 0 ? `\`${exit.command}\`` : void 0;
+  switch (exit.outcome) {
+    case "passed":
+      return { outcome: "pass", reason: "Verified: every step of the script exited 0.", checks: check(true, "every step exited 0"), decidedAt, reported: "done" };
+    case "failed": {
+      const said = `${command ?? "it"} ${statusText(exit.status)}`;
+      const reported = exit.status.error !== void 0 ? "blocked" : "failed";
+      return { outcome: "fail", reason: withTail(`The script failed: ${said}.`, exit.errorTail, exit.fullOutput), checks: check(false, said), decidedAt, reported };
+    }
+    case "timed-out": {
+      const said = `the time limit of ${durationText(exit.timeoutMs)} ran out${command ? ` while ${command} ran` : ""}, so it was ended`;
+      return { outcome: "fail", reason: withTail(`The script failed: ${said}.`, exit.errorTail, exit.fullOutput), checks: check(false, said), decidedAt, reported: "failed" };
+    }
+    case "stopped": {
+      const said = `it was stopped${command ? ` while ${command} ran` : ""}`;
+      return { outcome: "fail", reason: withTail(`The script did not finish: ${said}.`, "", exit.fullOutput), checks: check(false, said), decidedAt };
+    }
   }
-  return { tasks, handoff: handoffOf(run) };
+}
+function durationText(ms) {
+  if (ms % 6e4 === 0) return `${ms / 6e4} minute${ms === 6e4 ? "" : "s"}`;
+  const seconds = Math.round(ms / 100) / 10;
+  return `${seconds} second${seconds === 1 ? "" : "s"}`;
+}
+function reportedVerdict(report) {
+  const checks = [
+    {
+      name: "task_complete",
+      passed: report.status === "done",
+      skipped: false,
+      detail: `the runner called task_complete with status "${report.status}"`
+    }
+  ];
+  const decidedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const reported = report.status;
+  if (report.status === "done") {
+    return { outcome: "pass", reason: "Verified: the runner reported completion through task_complete. Task completed successfully.", checks, decidedAt, reported };
+  }
+  const why = report.reason?.trim() || report.summary?.trim().split(/\n\s*\n/)[0].trim() || "no reason given";
+  return { outcome: "fail", reason: `The runner reported the task ${report.status}: ${why}`, checks, decidedAt, reported };
 }
 
 // src/services/TaskRefs.ts
@@ -301,6 +705,30 @@ function migrateLoadedTasks(tasks) {
     migrateLoadedTasks(task.subtasks ?? []);
   }
 }
+function failInterruptedTasks(tasks, now) {
+  for (const task of flattenTasks(tasks)) {
+    if (task.status !== "in_progress") continue;
+    task.status = "failed";
+    task.verdict = interruptedVerdict(now);
+  }
+}
+function releaseMadeManual(tasks, live = () => false) {
+  for (const task of flattenTasks(tasks)) {
+    if (task.type !== "user" || live(task.id) || task.status !== "failed" && task.status !== "awaiting_user") continue;
+    task.status = "pending";
+    delete task.awaitingReason;
+    delete task.resumeAt;
+  }
+}
+function settleOwedRepairs(plan) {
+  const records = plan.isolation?.run.tasks;
+  if (!records) return;
+  for (const task of flattenTasks(plan.tasks)) {
+    if (task.status !== "pending" && task.status !== "approved" || records[task.id]?.status !== "conflict") continue;
+    task.status = "awaiting_user";
+    task.awaitingReason = "conflict";
+  }
+}
 function dropRetiredPlanFields(plan) {
   const raw = plan;
   delete raw.researchBudget;
@@ -599,6 +1027,7 @@ function keepExecutionState(current, rewrite) {
         ...t,
         status: prior?.status ?? "pending",
         skipReason: prior?.skipReason,
+        reverted: prior?.reverted,
         verdict: prior?.verdict,
         outputSummary: prior?.outputSummary,
         handoff: prior?.handoff,
@@ -609,6 +1038,7 @@ function keepExecutionState(current, rewrite) {
         attempted: prior?.attempted,
         attemptUsage: prior?.attemptUsage,
         loopRound: prior?.loopRound,
+        waitsEnded: prior?.waitsEnded,
         // Where a task that has run ran is fixed, like its runner session (ADR-0020).
         ...prior?.status === "failed" ? { ops: prior.ops } : {},
         forcedPastGate: prior?.forcedPastGate,
@@ -647,11 +1077,14 @@ export {
   absorbRemoval,
   layoutOf,
   changedReposOf,
-  taskIsolationOf,
+  landedInRepo,
+  taskIsolationsOf,
   handoffOf,
   migratePlanIsolation,
   migratePlanStateIsolation,
   isolationViewOfPlan,
+  VerdictEngine,
+  endedByExit,
   taskOrderLabel,
   taskRef,
   titledTaskRef,
@@ -661,6 +1094,9 @@ export {
   resolveUserTaskRef,
   isAwaitingReason,
   migrateLoadedTasks,
+  failInterruptedTasks,
+  releaseMadeManual,
+  settleOwedRepairs,
   dropRetiredPlanFields,
   migrateLoadedPlan,
   isUserMessage,
@@ -689,4 +1125,4 @@ export {
   stampOrigin,
   keepExecutionState
 };
-//# sourceMappingURL=chunk-QTZ5XTBY.mjs.map
+//# sourceMappingURL=chunk-F6WS3JLQ.mjs.map