@ordewell/core 0.10.10 → 0.10.12

package/dist/index.mjs

@@ -21628,9 +21628,11 @@ function plannerNotReadyFor(config) {
 var TERMINAL_UI_COMMANDS = {
   pickPlanner: "/planner",
   setKey: () => "/key",
-  setModel: "/model"
+  // `/planner` walks harness, model and effort in one flow; there is no
+  // separate `/model` (or `/planner-effort`) to point at.
+  setModel: "/planner"
 };
-var CHAT_COMMANDS = { ...TERMINAL_UI_COMMANDS, setModel: "/model set" };
+var CHAT_COMMANDS = { ...TERMINAL_UI_COMMANDS };
 var HEADLESS_CLI_COMMANDS = {
   pickPlanner: "ordewell planner <id>",
   setKey: (provider) => `ordewell key set ${provider} <key>`,
@@ -21644,7 +21646,7 @@ function harnessPlannerNames() {
 var PLANNER_ESCAPE_HINT = `or pick a coding agent with ${TERMINAL_UI_COMMANDS.pickPlanner}: it plans with no API key`;
 function describePlannerNotReady(reason, commands) {
   if (reason.code === "no_model") {
-    return `No planner model selected for ${reason.label}. Pick one with ${commands.setModel}, or switch planner with ${commands.pickPlanner}.`;
+    return commands.setModel === commands.pickPlanner ? `No planner model selected for ${reason.label}. Pick one with ${commands.setModel}.` : `No planner model selected for ${reason.label}. Pick one with ${commands.setModel}, or switch planner with ${commands.pickPlanner}.`;
   }
   const lead = `No planner is ready. Pick one with ${commands.pickPlanner}: ${harnessPlannerNames()} plan with no API key.`;
   if (reason.code === "no_base_url") {
@@ -32377,6 +32379,9 @@ var StructuredSession = class extends AbstractRunnerSession {
   text;
   state = "idle";
   turn = null;
+  /** A `task_complete` report waiting for its turn to close; the verdict is published then. */
+  completionReport = null;
+  completionTimer = null;
   /** A terminal event ends the turn before the adapter releases its send. */
   sending = null;
   turnCount = 0;
@@ -32385,6 +32390,8 @@ var StructuredSession = class extends AbstractRunnerSession {
   interrupting = null;
   /** The wind-down once {@link stop} was asked for: the same for every caller, and nothing new is sent meanwhile. */
   stopping = null;
+  /** The process is handling its exit: nothing new may be queued, so a held report can still publish. */
+  exiting = false;
   lastSessionId = null;
   lastSessionCost = null;
   structuredEmitter = new EventEmitter2();
@@ -32435,7 +32442,9 @@ var StructuredSession = class extends AbstractRunnerSession {
       create: () => this.launch.createAdapter(this.launch.runner, this.launch.deps),
       issueToken: () => server4.issueTaskToken(scope, {
         taskComplete: async (report) => {
-          this.structuredEmitter.emit("taskComplete", report);
+          this.completionReport = report;
+          if (this.completionTimer) clearTimeout(this.completionTimer);
+          this.completionTimer = setTimeout(() => this.flushCompletion(), this.launch.interruptGraceMs);
           return { text: "Recorded. End your turn now." };
         },
         checkpoint: async ({ question }, { signal }) => {
@@ -32467,6 +32476,9 @@ var StructuredSession = class extends AbstractRunnerSession {
     this.toolToken = null;
   }
   baseHandleExit(code) {
+    this.exiting = true;
+    this.undeliverQueued();
+    this.flushCompletion();
     this.ended.abort();
     this.revokeTools();
     this.undeliverQueued();
@@ -32562,7 +32574,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     this.messageCount += 1;
     const id = `msg-${this.messageCount}`;
     const sender2 = opening.from ? { from: opening.from } : {};
-    if (this.exited || this.stopping) this.emitEvent({ type: "message_undelivered", messageId: id, text, ...sender2 });
+    if (this.exited || this.exiting || this.stopping) this.emitEvent({ type: "message_undelivered", messageId: id, text, ...sender2 });
     else if (this.state === "idle" && this.adapterStarted && !this.sending) this.deliver(text, opening);
     else {
       this.state = "working";
@@ -32617,7 +32629,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     });
   }
   runningTurn() {
-    return !this.exited && !this.stopping && this.adapter !== null && this.turn !== null && !this.turn.ended;
+    return !this.exited && !this.exiting && !this.stopping && this.adapter !== null && this.turn !== null && !this.turn.ended;
   }
   /** No runner can recall a message once offered to it, so only a queued one comes back. */
   removeQueued(id) {
@@ -32748,6 +32760,7 @@ var StructuredSession = class extends AbstractRunnerSession {
   /** `message` is what opened the turn: a queued one has an id, one delivered straight from idle only its sender. */
   openTurn(text, message) {
     this.turnCount += 1;
+    this.discardCompletion();
     const turn = { id: this.turnCount, abort: new AbortController(), ended: false, reason: "completed", steerRefused: false };
     this.turn = turn;
     this.state = "working";
@@ -32796,7 +32809,7 @@ var StructuredSession = class extends AbstractRunnerSession {
   offerNext() {
     const adapter = this.adapter;
     const turn = this.turn;
-    if (!adapter?.steer || !turn || turn.ended || turn.steerRefused || this.interrupting || this.exited || this.stopping) return;
+    if (!adapter?.steer || !turn || turn.ended || turn.steerRefused || this.interrupting || this.exited || this.exiting || this.stopping) return;
     if (this.queue.some((m) => m.stage === "steering")) return;
     const next = this.queue.find((m) => m.stage === "queued");
     if (!next || next.command) return;
@@ -32840,6 +32853,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     } else if (event.type === "permission_request") this.openPermission(adapter, event);
     else if (event.type === "permission_cancelled") this.cancelPermission(adapter, event.id);
     else if (event.type === "message_delivered") {
+      this.discardCompletion();
       const message = this.delivered(event.id);
       if (message) this.emitEvent({ type: "message_delivered", messageId: message.id, text: message.text, ...message.from ? { from: message.from } : {} });
     } else if (event.type === "message_dropped") {
@@ -32920,6 +32934,24 @@ var StructuredSession = class extends AbstractRunnerSession {
     }
     this.emitEvent(event);
   }
+  /** Publish a `task_complete` report whose turn has closed, or that waited out the grace. */
+  flushCompletion() {
+    if (this.completionTimer) {
+      clearTimeout(this.completionTimer);
+      this.completionTimer = null;
+    }
+    const report = this.completionReport;
+    this.completionReport = null;
+    if (report) this.structuredEmitter.emit("taskComplete", report);
+  }
+  /** A message the runner reads, or a turn it opens, voids a report made before it (ADR-0023, D6). */
+  discardCompletion() {
+    if (this.completionTimer) {
+      clearTimeout(this.completionTimer);
+      this.completionTimer = null;
+    }
+    this.completionReport = null;
+  }
   /**
    * A queued message goes out as the turn closes, and the state never passes
    * through `idle` on the way, so a listener told the turn ended can already
@@ -32932,6 +32964,7 @@ var StructuredSession = class extends AbstractRunnerSession {
     turn.ended = true;
     this.text.endTurn();
     this.emitEvent({ type: "turn_end", reason });
+    this.flushCompletion();
     if (reason === "failed") this.undeliverQueued();
     this.state = !this.exited && this.queue.length ? "working" : "idle";
     this.structuredEmitter.emit("turnEnd", reason);
@@ -32942,7 +32975,7 @@ var StructuredSession = class extends AbstractRunnerSession {
    * back in Ordewell's hands: while it is on offer or owed, nothing overtakes it.
    */
   deliverNext() {
-    if (this.exited || this.stopping || this.sending || this.turn && !this.turn.ended) return;
+    if (this.exited || this.exiting || this.stopping || this.sending || this.turn && !this.turn.ended) return;
     const head = this.queue[0];
     if (!head || this.queue.some((message) => message.stage !== "queued")) return;
     this.queue.shift();