@ordewell/core 0.11.3 → 0.12.0

package/dist/testing.d.mts

@@ -1,5 +1,5 @@
-import { R as IRunnerSession, ar as QueuedTaskMessage, b6 as StructuredTurnEnd, b5 as StructuredEvent, bc as TaskCompleteArgs, t as CheckpointAnswer, aX as ScriptExit, be as TaskMessageFrom, aE as RunnerCommand, S as InvokedCommand, k as ApprovalDecision, O as IConfig, P as IFileSystem } from './IRunner-ihalYfTo.mjs';
-import { y as IntegrationDisposal, aA as RunnerSessionCost, x as IWorktreeIsolation, J as IsolationAvailability, R as IsolationMergeResult, b4 as TreeSnapshot, aF as SetupFailure, U as IsolationPruneResult, V as IsolationRemoval, S as IsolationOutcome, ao as RepairEvidence, X as IsolationRun, aS as Task, ah as PrepareIntent, ai as PreparedTask, q as HandoffCommit, K as IsolationHandoff } from './Task-BL4Idm9r.mjs';
+import { R as IRunnerSession, ar as QueuedTaskMessage, b6 as StructuredTurnEnd, b5 as StructuredEvent, bc as TaskCompleteArgs, t as CheckpointAnswer, aX as ScriptExit, be as TaskMessageFrom, aE as RunnerCommand, S as InvokedCommand, k as ApprovalDecision, O as IConfig, P as IFileSystem } from './IRunner-BwzyUVIL.mjs';
+import { J as IntegrationDisposal, aL as RunnerSessionCost, z as IWorktreeIsolation, L as IsolationAvailability, T as IsolationMergeResult, bf as TreeSnapshot, aQ as SetupFailure, W as IsolationPruneResult, X as IsolationRemoval, U as IsolationOutcome, _ as IsolationRevertResult, aH as RevertCommand, aw as RepairEvidence, a0 as IsolationRun, b1 as Task, ao as PrepareIntent, ap as PreparedTask, q as HandoffCommit, a7 as LandedWork, aI as RevertWatch, M as IsolationHandoff } from './Task-BTEH-ztX.mjs';
 import 'child_process';
 import 'zod/v4';
 
@@ -131,6 +131,9 @@ type FakeIsolationCall = {
 } | {
     op: 'discard';
     integration: IntegrationDisposal;
+} | {
+    op: 'readLanded' | 'revert';
+    taskIds: readonly string[];
 };
 /**
  * An in-memory {@link IWorktreeIsolation} for scheduling tests: no git, no
@@ -179,17 +182,26 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     removal: IsolationRemoval;
     /** Per task id; a task not listed integrates as `merged`. */
     outcomes: Map<string, IsolationOutcome>;
+    /** What `revert` stops with; a revert that goes through when null. */
+    revertStop: Exclude<IsolationRevertResult, {
+        outcome: 'reverted';
+    }> | null;
+    /** What `readLanded` finds of a task's work in the user's branch, by task id. */
+    inBranch: Map<string, RevertCommand[]>;
     /** Per task id, what `verifyRepair` finds; a task not listed passes. */
     repairEvidence: Map<string, RepairEvidence>;
     calls: FakeIsolationCall[];
     private holds;
     private verifyHolds;
+    private revertHold;
     private runCount;
     private log;
     /** Task ids in the order `op` was called for them. */
     taskIdsFor(op: 'prepare' | 'reopen' | 'verifyRepair' | 'integrate' | 'release'): string[];
     /** Make `integrate` for this task wait until the returned function is called. */
     holdIntegration(taskId: string): () => void;
+    /** Make the next `revert` wait, past its `refusal`, until the returned function is called. */
+    holdRevert(): () => void;
     /** Make `verifyRepair` for this task wait until the returned function is called. */
     holdVerification(taskId: string): () => void;
     isActive(workspaceRoot: string): Promise<IsolationAvailability>;
@@ -204,6 +216,10 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     verifyRepair(task: Task, _run: IsolationRun): Promise<RepairEvidence>;
     /** Like git: the landing is recorded and persisted before the (held) merge, and cleared once it settles. */
     integrate(task: Task, run: IsolationRun, persist?: () => void, commit?: HandoffCommit): Promise<IsolationOutcome>;
+    /** Newest landing first, read as the plan's highest order: scheduling tests land in plan order. */
+    readLanded(run: IsolationRun, taskIds: readonly string[]): Promise<LandedWork>;
+    /** Like git: the turn, then the judgement, then the records go in one step with the tasks back. */
+    revert(run: IsolationRun, taskIds: readonly string[], watch: RevertWatch): Promise<IsolationRevertResult>;
     release(run: IsolationRun, taskId: string, opts: {
         keep: boolean;
     }): Promise<IsolationRemoval>;

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
-import { R as IRunnerSession, ar as QueuedTaskMessage, b6 as StructuredTurnEnd, b5 as StructuredEvent, bc as TaskCompleteArgs, t as CheckpointAnswer, aX as ScriptExit, be as TaskMessageFrom, aE as RunnerCommand, S as InvokedCommand, k as ApprovalDecision, O as IConfig, P as IFileSystem } from './IRunner-DOMtDTVt.js';
-import { y as IntegrationDisposal, aA as RunnerSessionCost, x as IWorktreeIsolation, J as IsolationAvailability, R as IsolationMergeResult, b4 as TreeSnapshot, aF as SetupFailure, U as IsolationPruneResult, V as IsolationRemoval, S as IsolationOutcome, ao as RepairEvidence, X as IsolationRun, aS as Task, ah as PrepareIntent, ai as PreparedTask, q as HandoffCommit, K as IsolationHandoff } from './Task-BL4Idm9r.js';
+import { R as IRunnerSession, ar as QueuedTaskMessage, b6 as StructuredTurnEnd, b5 as StructuredEvent, bc as TaskCompleteArgs, t as CheckpointAnswer, aX as ScriptExit, be as TaskMessageFrom, aE as RunnerCommand, S as InvokedCommand, k as ApprovalDecision, O as IConfig, P as IFileSystem } from './IRunner-DjJkYwko.js';
+import { J as IntegrationDisposal, aL as RunnerSessionCost, z as IWorktreeIsolation, L as IsolationAvailability, T as IsolationMergeResult, bf as TreeSnapshot, aQ as SetupFailure, W as IsolationPruneResult, X as IsolationRemoval, U as IsolationOutcome, _ as IsolationRevertResult, aH as RevertCommand, aw as RepairEvidence, a0 as IsolationRun, b1 as Task, ao as PrepareIntent, ap as PreparedTask, q as HandoffCommit, a7 as LandedWork, aI as RevertWatch, M as IsolationHandoff } from './Task-BTEH-ztX.js';
 import 'child_process';
 import 'zod/v4';
 
@@ -131,6 +131,9 @@ type FakeIsolationCall = {
 } | {
     op: 'discard';
     integration: IntegrationDisposal;
+} | {
+    op: 'readLanded' | 'revert';
+    taskIds: readonly string[];
 };
 /**
  * An in-memory {@link IWorktreeIsolation} for scheduling tests: no git, no
@@ -179,17 +182,26 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     removal: IsolationRemoval;
     /** Per task id; a task not listed integrates as `merged`. */
     outcomes: Map<string, IsolationOutcome>;
+    /** What `revert` stops with; a revert that goes through when null. */
+    revertStop: Exclude<IsolationRevertResult, {
+        outcome: 'reverted';
+    }> | null;
+    /** What `readLanded` finds of a task's work in the user's branch, by task id. */
+    inBranch: Map<string, RevertCommand[]>;
     /** Per task id, what `verifyRepair` finds; a task not listed passes. */
     repairEvidence: Map<string, RepairEvidence>;
     calls: FakeIsolationCall[];
     private holds;
     private verifyHolds;
+    private revertHold;
     private runCount;
     private log;
     /** Task ids in the order `op` was called for them. */
     taskIdsFor(op: 'prepare' | 'reopen' | 'verifyRepair' | 'integrate' | 'release'): string[];
     /** Make `integrate` for this task wait until the returned function is called. */
     holdIntegration(taskId: string): () => void;
+    /** Make the next `revert` wait, past its `refusal`, until the returned function is called. */
+    holdRevert(): () => void;
     /** Make `verifyRepair` for this task wait until the returned function is called. */
     holdVerification(taskId: string): () => void;
     isActive(workspaceRoot: string): Promise<IsolationAvailability>;
@@ -204,6 +216,10 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     verifyRepair(task: Task, _run: IsolationRun): Promise<RepairEvidence>;
     /** Like git: the landing is recorded and persisted before the (held) merge, and cleared once it settles. */
     integrate(task: Task, run: IsolationRun, persist?: () => void, commit?: HandoffCommit): Promise<IsolationOutcome>;
+    /** Newest landing first, read as the plan's highest order: scheduling tests land in plan order. */
+    readLanded(run: IsolationRun, taskIds: readonly string[]): Promise<LandedWork>;
+    /** Like git: the turn, then the judgement, then the records go in one step with the tasks back. */
+    revert(run: IsolationRun, taskIds: readonly string[], watch: RevertWatch): Promise<IsolationRevertResult>;
     release(run: IsolationRun, taskId: string, opts: {
         keep: boolean;
     }): Promise<IsolationRemoval>;

package/dist/testing.js

@@ -45,6 +45,9 @@ function integrationBranchFor(runId) {
 function noRemoval() {
   return { preserved: [], refused: [] };
 }
+function landedInRepo(run, record, repoPath) {
+  return !!record.repos[repoPath]?.changed || run.landings?.[record.taskId]?.[repoPath] !== void 0;
+}
 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) => ({
@@ -60,7 +63,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)
   };
@@ -107,6 +110,7 @@ function fakeConfig(overrides = {}) {
     // Off so a test that is not about the allowlist sees every prompt it raises.
     approvalDefaults: false,
     effectAllowlist: [],
+    notifyCommand: [],
     webReadBudget: 40,
     plannerNativeShell: false,
     setProviderModelLists: () => {
@@ -377,11 +381,16 @@ var FakeWorktreeIsolation = class {
   removal = noRemoval();
   /** Per task id; a task not listed integrates as `merged`. */
   outcomes = /* @__PURE__ */ new Map();
+  /** What `revert` stops with; a revert that goes through when null. */
+  revertStop = null;
+  /** What `readLanded` finds of a task's work in the user's branch, by task id. */
+  inBranch = /* @__PURE__ */ new Map();
   /** Per task id, what `verifyRepair` finds; a task not listed passes. */
   repairEvidence = /* @__PURE__ */ new Map();
   calls = [];
   holds = /* @__PURE__ */ new Map();
   verifyHolds = /* @__PURE__ */ new Map();
+  revertHold = null;
   runCount = 0;
   log(call) {
     this.calls.push(call);
@@ -398,6 +407,14 @@ var FakeWorktreeIsolation = class {
     }));
     return open;
   }
+  /** Make the next `revert` wait, past its `refusal`, until the returned function is called. */
+  holdRevert() {
+    let open;
+    this.revertHold = new Promise((resolve) => {
+      open = resolve;
+    });
+    return open;
+  }
   /** Make `verifyRepair` for this task wait until the returned function is called. */
   holdVerification(taskId) {
     let open;
@@ -431,7 +448,9 @@ var FakeWorktreeIsolation = class {
       })),
       shared: [...this.shared],
       sharedRepos: [...this.sharedRepos],
-      tasks: {}
+      tasks: {},
+      keepsEveryLanding: true,
+      carried: {}
     };
   }
   async prepare(task, run, _intent, opts = {}) {
@@ -494,6 +513,10 @@ var FakeWorktreeIsolation = class {
     if (outcome === "merged") {
       delete record.conflictRepo;
       delete record.conflictFiles;
+      for (const repo of changed) {
+        ((run.landings ??= {})[task.id] ??= {})[repo] = [...run.landings?.[task.id]?.[repo] ?? [], `tip-${repo}`];
+        (run.landedTasks ??= {})[task.id] = { taskId: task.id, order: task.order, title: task.title };
+      }
     } else {
       record.conflictRepo = this.stopsIn.get(task.id) ?? changed[0] ?? SELF_REPO;
       const files = this.conflictFiles.get(task.id);
@@ -502,6 +525,44 @@ var FakeWorktreeIsolation = class {
     }
     return outcome;
   }
+  /** Newest landing first, read as the plan's highest order: scheduling tests land in plan order. */
+  async readLanded(run, taskIds) {
+    this.log({ op: "readLanded", taskIds });
+    const records = taskIds.flatMap((id) => run.tasks[id] ?? run.landedTasks?.[id] ?? []).sort((a, b) => b.order - a.order);
+    const tasks = records.map((r) => ({
+      taskId: r.taskId,
+      order: r.order,
+      title: r.title,
+      repos: Object.keys(run.landings?.[r.taskId] ?? {})
+    }));
+    return { ok: true, tasks, inBranch: records.flatMap((r) => this.inBranch.get(r.taskId) ?? []) };
+  }
+  /** Like git: the turn, then the judgement, then the records go in one step with the tasks back. */
+  async revert(run, taskIds, watch) {
+    this.log({ op: "revert", taskIds });
+    const hold = this.revertHold;
+    this.revertHold = null;
+    await hold;
+    const reason = watch.refusal();
+    if (reason) return { outcome: "refused", reason };
+    if (this.revertStop) return this.revertStop;
+    const landed = await this.readLanded(run, taskIds);
+    if (!landed.ok) return { outcome: "failed", error: landed.error };
+    if (landed.inBranch.length > 0) return { outcome: "in-branch", commands: landed.inBranch };
+    run.landing = { taskId: taskIds[0], tips: {}, reverts: {} };
+    watch.persist();
+    delete run.landing;
+    for (const id of taskIds) {
+      if (run.tasks[id]?.status === "merged") delete run.tasks[id];
+      else if (run.tasks[id]?.status === "conflict") run.tasks[id].status = "kept";
+      delete run.landings?.[id];
+      delete run.landedTasks?.[id];
+      delete run.landedOn?.[id];
+    }
+    run.reverted = true;
+    watch.settled(taskIds);
+    return { outcome: "reverted", tasks: landed.tasks };
+  }
   async release(run, taskId, opts) {
     this.log({ op: "release", taskId, keep: opts.keep });
     const record = run.tasks[taskId];
@@ -543,13 +604,16 @@ var FakeWorktreeIsolation = class {
   }
   async findInHead(run) {
     this.log({ op: "findInHead" });
-    const found = [];
+    const changed = [];
     for (const record of Object.values(run.tasks)) {
-      if (record.status !== "merged" || record.inHead || !this.mergedByHand.has(record.taskId)) continue;
-      record.inHead = true;
-      found.push(record.taskId);
+      if (record.status !== "merged") continue;
+      const merged = this.mergedByHand.has(record.taskId);
+      if (merged === !!record.inHead) continue;
+      if (merged) record.inHead = true;
+      else delete record.inHead;
+      changed.push(record.taskId);
     }
-    return found;
+    return changed;
   }
   async snapshotTree() {
     this.log({ op: "snapshotTree" });