@ordewell/core 0.9.0 → 0.10.0

package/dist/plan-utils.mjs

@@ -2,28 +2,29 @@ import {
   CHECKPOINT_TRUNCATE_LENGTH,
   EMPTY_CONVERSATION,
   EMPTY_HOLD,
+  EMPTY_RUN,
   EMPTY_TASK_LOG,
-  NOT_STARTED,
   NO_TURN,
+  SUPERVISOR_LEVEL_LABEL,
+  addAttemptUsage,
+  addModelUsage,
+  addPlannerUsage,
+  addUsage,
+  addUsageTotals,
   aheadOfDraft,
-  approvalLabel,
-  awaitingLabel,
-  canMergeTasks,
-  canSetDependencies,
-  canSplitTask,
+  blockingFailures,
   capConflictFiles,
-  dependencyCandidates,
   dependentsNotice,
-  dependentsOf,
   diffRows,
   diffStat,
   diffSummary,
   drainNext,
+  endAttemptUsage,
   followTurn,
   fromTranscript,
   hasHiddenDetail,
   holdPrompt,
-  isTaskRunning,
+  isMeasured,
   markAction,
   markRequestFor,
   namedRepos,
@@ -31,45 +32,77 @@ import {
   opsEditable,
   outputLines,
   outputPreview,
+  parseCount,
+  partedPromptUsage,
   pastGateConfirmation,
+  planUsage,
+  plannerContextFill,
   reduceConversation,
   reduceTaskLog,
   replayTaskLog,
   runnerToolSubject,
+  startAttemptUsage,
   stopTurn,
   summarizeToolCall,
+  takeAt,
   taskRowActions,
   taskRowView,
   taskStartedNotice,
-  taskStatusKind,
   titledRefs,
   toolHeadline,
   truncateCheckpointSummary,
   unsendAll,
-  unsendLatest
-} from "./chunk-QUARDKVT.mjs";
-import "./chunk-H5O74L77.mjs";
+  unsendLatest,
+  usageLine
+} from "./chunk-CH5IGWFS.mjs";
+import {
+  NOT_STARTED,
+  approvalLabel,
+  awaitingLabel,
+  blockedByLabel,
+  canMergeTasks,
+  canSetDependencies,
+  canSplitTask,
+  dependencyCandidates,
+  dependentsOf,
+  isTaskRunning,
+  resumeLabel,
+  resumeTime,
+  skippedLabel,
+  taskStatusKind
+} from "./chunk-DJAPDO6E.mjs";
 import {
   DEFAULT_RUNNERS,
   loadedSkillTokens,
-  skillTokens
-} from "./chunk-UUU46PVQ.mjs";
-import {
+  pausedOnLimit,
+  resolveTaskRef,
+  skillTokens,
   taskOrderLabel,
   taskRef,
-  titledTaskRef
-} from "./chunk-V3JHS7AX.mjs";
+  taskRefOf,
+  titledTaskRef,
+  titledTaskRefOf
+} from "./chunk-2IIRSBEQ.mjs";
 export {
   CHECKPOINT_TRUNCATE_LENGTH,
   DEFAULT_RUNNERS,
   EMPTY_CONVERSATION,
   EMPTY_HOLD,
+  EMPTY_RUN,
   EMPTY_TASK_LOG,
   NOT_STARTED,
   NO_TURN,
+  SUPERVISOR_LEVEL_LABEL,
+  addAttemptUsage,
+  addModelUsage,
+  addPlannerUsage,
+  addUsage,
+  addUsageTotals,
   aheadOfDraft,
   approvalLabel,
   awaitingLabel,
+  blockedByLabel,
+  blockingFailures,
   canMergeTasks,
   canSetDependencies,
   canSplitTask,
@@ -81,10 +114,12 @@ export {
   diffStat,
   diffSummary,
   drainNext,
+  endAttemptUsage,
   followTurn,
   fromTranscript,
   hasHiddenDetail,
   holdPrompt,
+  isMeasured,
   isTaskRunning,
   loadedSkillTokens,
   markAction,
@@ -94,25 +129,39 @@ export {
   opsEditable,
   outputLines,
   outputPreview,
+  parseCount,
+  partedPromptUsage,
   pastGateConfirmation,
+  pausedOnLimit,
+  planUsage,
+  plannerContextFill,
   reduceConversation,
   reduceTaskLog,
   replayTaskLog,
+  resolveTaskRef,
+  resumeLabel,
+  resumeTime,
   runnerToolSubject,
   skillTokens,
+  skippedLabel,
+  startAttemptUsage,
   stopTurn,
   summarizeToolCall,
+  takeAt,
   taskOrderLabel,
   taskRef,
+  taskRefOf,
   taskRowActions,
   taskRowView,
   taskStartedNotice,
   taskStatusKind,
   titledRefs,
   titledTaskRef,
+  titledTaskRefOf,
   toolHeadline,
   truncateCheckpointSummary,
   unsendAll,
-  unsendLatest
+  unsendLatest,
+  usageLine
 };
 //# sourceMappingURL=plan-utils.mjs.map

package/dist/testing.d.mts

@@ -1,6 +1,6 @@
-import { w as IRunnerSession, a0 as QueuedTaskMessage, aa as StructuredTurnEnd, a9 as StructuredEvent, ae as TaskCompleteArgs, p as CheckpointAnswer, h as ApprovalDecision, u as IConfig } from './IRunner-CxiymkP_.mjs';
-import { I as IFileSystem } from './IFileSystem-_m7HdoxJ.mjs';
-import { d as IntegrationDisposal, I as IWorktreeIsolation, f as IsolationAvailability, n as IsolationMergeResult, am as TreeSnapshot, p as IsolationPruneResult, q as IsolationRemoval, o as IsolationOutcome, K as RepairEvidence, s as IsolationRun, a9 as Task, H as PreparedTask, g as IsolationHandoff } from './Task-1Q19y7sZ.mjs';
+import { B as IRunnerSession, aa as QueuedTaskMessage, au as StructuredTurnEnd, at as StructuredEvent, az as TaskCompleteArgs, r as CheckpointAnswer, aB as TaskMessageFrom, ah as RunnerCommand, H as InvokedCommand, j as ApprovalDecision, y as IConfig } from './IRunner-hWAJC4hg.mjs';
+import { I as IFileSystem } from './IFileSystem-Bj6fy1cG.mjs';
+import { g as IntegrationDisposal, I as IWorktreeIsolation, i as IsolationAvailability, q as IsolationMergeResult, am as TreeSnapshot, a0 as SetupFailure, s as IsolationPruneResult, t as IsolationRemoval, r as IsolationOutcome, T as RepairEvidence, v as IsolationRun, ac as Task, Q as PreparedTask, j as IsolationHandoff } from './Task-CxwnCJLi.mjs';
 import 'child_process';
 import 'zod/v4';
 
@@ -29,6 +29,8 @@ declare class FakeRunnerSession implements IRunnerSession {
     messages: QueuedTaskMessage[];
     /** Every message a turn was started with, in order. */
     delivered: string[];
+    /** The ones of {@link delivered} Ordewell sent: the completion reminder (ADR-0018, W1). */
+    fromOrdewell: string[];
     interrupts: number;
     private messageCount;
     private turnEndCbs;
@@ -52,7 +54,7 @@ declare class FakeRunnerSession implements IRunnerSession {
     onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
     /** The runner calls `checkpoint`, as `StructuredSession` relays it; settles with the answer. */
     callCheckpoint(question: string, signal?: AbortSignal): Promise<CheckpointAnswer>;
-    sendMessage(text: string): string;
+    sendMessage(text: string, from?: TaskMessageFrom): string;
     /** Interrupts, and the turn that replaces the interrupted one opens with the forced message. */
     forceSend(text: string): string;
     forceSendQueued(id: string): boolean;
@@ -61,6 +63,13 @@ declare class FakeRunnerSession implements IRunnerSession {
     queued(): QueuedTaskMessage[];
     interrupt(): Promise<void>;
     nativeSessionId(): string | null;
+    /** What `commands()` reports: the runner's own commands (#66). */
+    runnerCommands: RunnerCommand[];
+    /** Every runner command invoked, in order. */
+    invoked: InvokedCommand[];
+    commands(): RunnerCommand[];
+    /** Runs it as a message that starts with it, which is what a runner reads. */
+    invokeCommand(name: string, args?: string): string;
     /** Every answer this session was given, in order. */
     answers: Array<{
         id: string;
@@ -75,6 +84,11 @@ declare class FakeRunnerSession implements IRunnerSession {
     emitEvent(event: StructuredEvent): void;
     /** The runner reads a queued message inside the running turn, as `StructuredSession` reports it (ADR-0023). */
     deliverMidTurn(id: string): void;
+    /**
+     * The turn ends without a `task_complete` call, and so does the turn the
+     * completion reminder opens if one was sent (ADR-0018, W1): the task waits for input.
+     */
+    waitForInput(): void;
     emitTurnEnd(reason: StructuredTurnEnd): void;
     private deliver;
 }
@@ -135,6 +149,7 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     shared: string[];
     sharedRepos: string[];
     copied: string[];
+    setupFailed: SetupFailure[];
     /** Set to make `startRun` throw, as git does when no repo of the group can be isolated. */
     startRunError: Error | null;
     /** Set to make `discard` / `sweep` throw after logging the call. */
@@ -153,12 +168,15 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     repairEvidence: Map<string, RepairEvidence>;
     calls: FakeIsolationCall[];
     private holds;
+    private verifyHolds;
     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 `verifyRepair` for this task wait until the returned function is called. */
+    holdVerification(taskId: string): () => void;
     isActive(workspaceRoot: string): Promise<IsolationAvailability>;
     /** Like git: once the tracked changes are stashed, the tree is no longer dirty. */
     stash(workspaceRoot: string): Promise<void>;

package/dist/testing.d.ts

@@ -1,6 +1,6 @@
-import { w as IRunnerSession, a0 as QueuedTaskMessage, aa as StructuredTurnEnd, a9 as StructuredEvent, ae as TaskCompleteArgs, p as CheckpointAnswer, h as ApprovalDecision, u as IConfig } from './IRunner-BiQio8gJ.js';
-import { I as IFileSystem } from './IFileSystem-DpaaFdit.js';
-import { d as IntegrationDisposal, I as IWorktreeIsolation, f as IsolationAvailability, n as IsolationMergeResult, am as TreeSnapshot, p as IsolationPruneResult, q as IsolationRemoval, o as IsolationOutcome, K as RepairEvidence, s as IsolationRun, a9 as Task, H as PreparedTask, g as IsolationHandoff } from './Task-1Q19y7sZ.js';
+import { B as IRunnerSession, aa as QueuedTaskMessage, au as StructuredTurnEnd, at as StructuredEvent, az as TaskCompleteArgs, r as CheckpointAnswer, aB as TaskMessageFrom, ah as RunnerCommand, H as InvokedCommand, j as ApprovalDecision, y as IConfig } from './IRunner-C7_SSpzG.js';
+import { I as IFileSystem } from './IFileSystem-BCJBHFwB.js';
+import { g as IntegrationDisposal, I as IWorktreeIsolation, i as IsolationAvailability, q as IsolationMergeResult, am as TreeSnapshot, a0 as SetupFailure, s as IsolationPruneResult, t as IsolationRemoval, r as IsolationOutcome, T as RepairEvidence, v as IsolationRun, ac as Task, Q as PreparedTask, j as IsolationHandoff } from './Task-CxwnCJLi.js';
 import 'child_process';
 import 'zod/v4';
 
@@ -29,6 +29,8 @@ declare class FakeRunnerSession implements IRunnerSession {
     messages: QueuedTaskMessage[];
     /** Every message a turn was started with, in order. */
     delivered: string[];
+    /** The ones of {@link delivered} Ordewell sent: the completion reminder (ADR-0018, W1). */
+    fromOrdewell: string[];
     interrupts: number;
     private messageCount;
     private turnEndCbs;
@@ -52,7 +54,7 @@ declare class FakeRunnerSession implements IRunnerSession {
     onToolCheckpoint(handler: (question: string, signal: AbortSignal) => Promise<CheckpointAnswer>): void;
     /** The runner calls `checkpoint`, as `StructuredSession` relays it; settles with the answer. */
     callCheckpoint(question: string, signal?: AbortSignal): Promise<CheckpointAnswer>;
-    sendMessage(text: string): string;
+    sendMessage(text: string, from?: TaskMessageFrom): string;
     /** Interrupts, and the turn that replaces the interrupted one opens with the forced message. */
     forceSend(text: string): string;
     forceSendQueued(id: string): boolean;
@@ -61,6 +63,13 @@ declare class FakeRunnerSession implements IRunnerSession {
     queued(): QueuedTaskMessage[];
     interrupt(): Promise<void>;
     nativeSessionId(): string | null;
+    /** What `commands()` reports: the runner's own commands (#66). */
+    runnerCommands: RunnerCommand[];
+    /** Every runner command invoked, in order. */
+    invoked: InvokedCommand[];
+    commands(): RunnerCommand[];
+    /** Runs it as a message that starts with it, which is what a runner reads. */
+    invokeCommand(name: string, args?: string): string;
     /** Every answer this session was given, in order. */
     answers: Array<{
         id: string;
@@ -75,6 +84,11 @@ declare class FakeRunnerSession implements IRunnerSession {
     emitEvent(event: StructuredEvent): void;
     /** The runner reads a queued message inside the running turn, as `StructuredSession` reports it (ADR-0023). */
     deliverMidTurn(id: string): void;
+    /**
+     * The turn ends without a `task_complete` call, and so does the turn the
+     * completion reminder opens if one was sent (ADR-0018, W1): the task waits for input.
+     */
+    waitForInput(): void;
     emitTurnEnd(reason: StructuredTurnEnd): void;
     private deliver;
 }
@@ -135,6 +149,7 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     shared: string[];
     sharedRepos: string[];
     copied: string[];
+    setupFailed: SetupFailure[];
     /** Set to make `startRun` throw, as git does when no repo of the group can be isolated. */
     startRunError: Error | null;
     /** Set to make `discard` / `sweep` throw after logging the call. */
@@ -153,12 +168,15 @@ declare class FakeWorktreeIsolation implements IWorktreeIsolation {
     repairEvidence: Map<string, RepairEvidence>;
     calls: FakeIsolationCall[];
     private holds;
+    private verifyHolds;
     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 `verifyRepair` for this task wait until the returned function is called. */
+    holdVerification(taskId: string): () => void;
     isActive(workspaceRoot: string): Promise<IsolationAvailability>;
     /** Like git: once the tracked changes are stashed, the tree is no longer dirty. */
     stash(workspaceRoot: string): Promise<void>;

package/dist/testing.js

@@ -102,6 +102,7 @@ function fakeConfig(overrides = {}) {
     approvalPreApproved: [],
     // Off so a test that is not about the allowlist sees every prompt it raises.
     approvalDefaults: false,
+    webReadBudget: 40,
     setProviderModelLists: () => {
     },
     getProviderBaseUrl: () => "",
@@ -141,6 +142,8 @@ var FakeRunnerSession = class {
   messages = [];
   /** Every message a turn was started with, in order. */
   delivered = [];
+  /** The ones of {@link delivered} Ordewell sent: the completion reminder (ADR-0018, W1). */
+  fromOrdewell = [];
   interrupts = 0;
   messageCount = 0;
   turnEndCbs = [];
@@ -195,11 +198,11 @@ var FakeRunnerSession = class {
     if (!this.checkpointHandler) throw new Error("no checkpoint handler attached");
     return this.checkpointHandler(question, signal);
   }
-  sendMessage(text) {
+  sendMessage(text, from) {
     this.messageCount += 1;
     const id = `msg-${this.messageCount}`;
-    if (this.state === "idle") this.deliver(text);
-    else this.messages.push({ id, text });
+    if (this.state === "idle") this.deliver(text, from);
+    else this.messages.push({ id, text, ...from ? { from } : {} });
     return id;
   }
   /** Interrupts, and the turn that replaces the interrupted one opens with the forced message. */
@@ -213,7 +216,8 @@ var FakeRunnerSession = class {
   }
   forceSendQueued(id) {
     const message = this.messages.find((m) => m.id === id);
-    if (!message || message.handedOver) return false;
+    if (!message) return false;
+    if (message.forced) return true;
     this.messages = this.messages.filter((m) => m !== message);
     this.putForced({ ...message, forced: true });
     if (this.state === "working") void this.interrupt();
@@ -238,6 +242,18 @@ var FakeRunnerSession = class {
   nativeSessionId() {
     return this.sessionId;
   }
+  /** What `commands()` reports: the runner's own commands (#66). */
+  runnerCommands = [];
+  /** Every runner command invoked, in order. */
+  invoked = [];
+  commands() {
+    return [...this.runnerCommands];
+  }
+  /** Runs it as a message that starts with it, which is what a runner reads. */
+  invokeCommand(name, args = "") {
+    this.invoked.push({ name, ...args.trim() ? { args: args.trim() } : {} });
+    return this.sendMessage(args.trim() ? `/${name} ${args.trim()}` : `/${name}`);
+  }
   /** Every answer this session was given, in order. */
   answers = [];
   openPermissions = /* @__PURE__ */ new Set();
@@ -264,18 +280,28 @@ var FakeRunnerSession = class {
     const message = this.messages.find((m) => m.id === id);
     if (!message) return;
     this.messages = this.messages.filter((m) => m !== message);
-    this.emitEvent({ type: "message_delivered", messageId: id, text: message.text });
+    this.emitEvent({ type: "message_delivered", messageId: id, text: message.text, ...message.from ? { from: message.from } : {} });
+  }
+  /**
+   * The turn ends without a `task_complete` call, and so does the turn the
+   * completion reminder opens if one was sent (ADR-0018, W1): the task waits for input.
+   */
+  waitForInput() {
+    const reminders = this.fromOrdewell.length;
+    this.emitTurnEnd("completed");
+    if (this.fromOrdewell.length > reminders) this.emitTurnEnd("completed");
   }
   emitTurnEnd(reason) {
     const next = this.messages.shift();
     if (!next) this.state = "idle";
     for (const cb of this.turnEndCbs) cb(reason);
-    if (next) this.deliver(next.text);
+    if (next) this.deliver(next.text, next.from);
   }
-  deliver(text) {
+  deliver(text, from) {
     this.state = "working";
     this.delivered.push(text);
-    this.emitEvent({ type: "turn_start", text });
+    if (from === "ordewell") this.fromOrdewell.push(text);
+    this.emitEvent({ type: "turn_start", text, ...from ? { from } : {} });
   }
 };
 var FakeWorktreeIsolation = class {
@@ -300,6 +326,7 @@ var FakeWorktreeIsolation = class {
   shared = [];
   sharedRepos = [];
   copied = [];
+  setupFailed = [];
   /** Set to make `startRun` throw, as git does when no repo of the group can be isolated. */
   startRunError = null;
   /** Set to make `discard` / `sweep` throw after logging the call. */
@@ -318,6 +345,7 @@ var FakeWorktreeIsolation = class {
   repairEvidence = /* @__PURE__ */ new Map();
   calls = [];
   holds = /* @__PURE__ */ new Map();
+  verifyHolds = /* @__PURE__ */ new Map();
   runCount = 0;
   log(call) {
     this.calls.push(call);
@@ -334,6 +362,14 @@ var FakeWorktreeIsolation = class {
     }));
     return open;
   }
+  /** Make `verifyRepair` for this task wait until the returned function is called. */
+  holdVerification(taskId) {
+    let open;
+    this.verifyHolds.set(taskId, new Promise((resolve) => {
+      open = resolve;
+    }));
+    return open;
+  }
   async isActive(workspaceRoot) {
     this.log({ op: "isActive", workspaceRoot });
     return this.availability;
@@ -376,7 +412,7 @@ var FakeWorktreeIsolation = class {
       status: "active",
       repos: Object.fromEntries(run.repos.map((r) => [r.path, { worktree: r.path === SELF_REPO ? cwd : `${cwd}/${r.path}`, linked: [] }]))
     };
-    return { cwd, branch, copied: [...this.copied] };
+    return { cwd, branch, copied: [...this.copied], ...this.setupFailed.length > 0 ? { setupFailed: [...this.setupFailed] } : {} };
   }
   /** Like git: the same cwd, each changed repo's tip recorded, the repair counted. */
   async reopen(task, run) {
@@ -393,6 +429,7 @@ var FakeWorktreeIsolation = class {
   }
   async verifyRepair(task, _run) {
     this.log({ op: "verifyRepair", taskId: task.id });
+    await this.verifyHolds.get(task.id);
     return this.repairEvidence.get(task.id) ?? { ok: true };
   }
   /** Like git: the landing is recorded and persisted before the (held) merge, and cleared once it settles. */