@goah/cli 0.13.3 → 0.13.4

package/dist/{chunk-KJ4HJCTK.js → chunk-5PZFP5CO.js}

@@ -2,30 +2,27 @@ import { createRequire as __goahCreateRequire } from "node:module";
 const require = __goahCreateRequire(import.meta.url);
 import {
   runnerPlugin
-} from "./chunk-D2DVAH37.js";
+} from "./chunk-R6GKCNTB.js";
 import {
   SQLITE_SCHEMA_VERSION,
   SqliteLedger
-} from "./chunk-YH6YJ2IB.js";
+} from "./chunk-CDELLMIJ.js";
 import {
   RunnerRouter,
   Supervisor,
   deriveRecoveryViews
-} from "./chunk-QBD6EJ2Z.js";
+} from "./chunk-SQJZ5OFH.js";
 import {
   ProcessRunner,
   piWorkerPath,
   resolveEnvSpec
-} from "./chunk-7E7V6OIU.js";
+} from "./chunk-EK6BTCFG.js";
 import {
   createPiModel
 } from "./chunk-6M3OOCKO.js";
 import {
   replayTranscript
 } from "./chunk-R6I3VKME.js";
-import {
-  normalizeAssistantText
-} from "./chunk-TJON22J4.js";
 
 // node_modules/.dist-original/index.js
 import { accessSync, chmodSync as chmodSync3, constants, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, closeSync, readFileSync as readFileSync3, renameSync, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -440,10 +437,7 @@ async function* turnFrames(turnId, ledger, isActive) {
       throw new Error("Turn disappeared");
     if (current.status !== "in_progress") {
       yield* drain();
-      const answer = ledger.turnItems(turnId).filter((item) => item.type === "assistant_message").at(-1);
-      const answerText = String(answer?.data?.text ?? "");
-      const streamed = answerText !== "" && ledger.readStream(`turn:${turnId}`).some((event) => event.type === "response.committed" ? event.data.text === answerText : event.type === "message.assistant.completed" && assistantEventText(event.data) === answerText);
-      yield { type: "result", value: { turn: { ...current, leaseToken: null }, ...answer && !streamed ? { response: { content: answerText } } : {} } };
+      yield { type: "result", value: { turn: { ...current, leaseToken: null } } };
       return;
     }
     await new Promise((resolve3) => setTimeout(resolve3, 50));
@@ -461,16 +455,6 @@ function requiredGoal(ledger, id) {
     throw new Error("goal not found");
   return goal;
 }
-function assistantEventText(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || !value.message || typeof value.message !== "object" || Array.isArray(value.message))
-    return "";
-  const content = value.message.content;
-  if (typeof content === "string")
-    return normalizeAssistantText(content);
-  if (!Array.isArray(content))
-    return "";
-  return content.map((item) => item && typeof item === "object" && !Array.isArray(item) && item.type === "text" && typeof item.text === "string" ? normalizeAssistantText(item.text) : "").filter(Boolean).join("\n");
-}
 function isTurnPresentationEvent(type) {
   return type.startsWith("message.") || type.startsWith("tool.") || type.startsWith("item.") || type.startsWith("turn.") || type === "response.committed" || type === "handoff.recorded" || type === "transcript.interrupted" || type === "transcript.completed";
 }

package/dist/{chunk-YH6YJ2IB.js → chunk-CDELLMIJ.js}

@@ -751,9 +751,25 @@ var SqliteLedger = class {
     return this.#transaction(() => this.#repairOpenTurnItems(id, reason, now, actor));
   }
   finishTurn(id, status, error, now, actor, mailIds = []) {
+    if (status === "completed")
+      throw new Error("successful Turn completion requires commitTurnResponse or commitHandoff");
     const current = this.#requiredTurn(id);
     return this.#transaction(() => this.#finishTurn(current, status, error, now, actor, mailIds));
   }
+  commitTurnResponse(id, responseItemId, now, actor, mailIds = []) {
+    return this.#transaction(() => {
+      const current = this.#requiredTurn(id);
+      if (current.goalId !== null)
+        throw new Error("Goal-bound Turn response requires commitHandoff");
+      const responseItem = this.turnItems(id).find((item) => item.id === responseItemId);
+      const text = responseItem && responseItem.type === "assistant_message" && responseItem.status === "completed" ? normalizeAssistantText(String(responseItem.data.text ?? "")) : "";
+      if (!responseItem || !text)
+        throw new Error("Turn response does not match a readable Assistant Item");
+      const streamId = `turn:${id}`;
+      this.#insertEvent({ streamId, ts: now, actor, type: "response.committed", data: { messageItemId: responseItem.id, text } });
+      return this.#finishTurn(current, "completed", null, now, actor, mailIds);
+    });
+  }
   releaseTurnProcess(id, actor) {
     if (actor !== "supervisor")
       throw new Error("only supervisor may release Runner process ownership");
@@ -1451,25 +1467,36 @@ var SqliteLedger = class {
     } else {
       if (event.type !== `turn.${turn.status}` || turn.attempt !== current.attempt || turn.runnerPid !== current.runnerPid)
         throw new Error(`turn event ${event.seq} has an invalid terminal transition`);
-      if (turn.status === "completed" && turn.goalId !== null)
-        this.#assertReplayGoalCompletion(turn, event);
+      if (turn.status === "completed") {
+        if (turn.goalId !== null)
+          this.#assertReplayGoalCompletion(turn, event);
+        else
+          this.#assertReplayResponseCompletion(turn, event);
+      }
     }
   }
+  #assertReplayResponseCompletion(turn, event) {
+    const responseRow = this.db.prepare("SELECT data FROM events WHERE stream_id=? AND type='response.committed' AND seq<? ORDER BY seq DESC LIMIT 1").get(`turn:${turn.id}`, event.seq);
+    if (!responseRow)
+      throw new Error(`turn event ${event.seq} completes without a committed response`);
+    const response = JSON.parse(responseRow.data);
+    const responseItem = this.turnItems(turn.id).find((item) => item.id === response.messageItemId && item.type === "assistant_message" && item.status === "completed");
+    if (!responseItem || normalizeAssistantText(String(responseItem.data.text ?? "")) !== response.text)
+      throw new Error(`turn event ${event.seq} has a mismatched committed response`);
+    return responseItem;
+  }
   #assertReplayGoalCompletion(turn, event) {
     if (turn.goalId === null || turn.goalRevision === null)
       throw new Error(`turn event ${event.seq} has no Goal commitment`);
     const items = this.turnItems(turn.id);
-    const responses = items.filter((item) => item.type === "assistant_message" && item.status === "completed" && typeof item.data.text === "string" && Boolean(item.data.text.trim()));
+    this.#assertReplayResponseCompletion(turn, event);
     const handoffItem = items.findLast((item) => item.type === "handoff" && item.status === "completed");
-    const responseRow = this.db.prepare("SELECT data FROM events WHERE stream_id=? AND type='response.committed' AND seq<? ORDER BY seq DESC LIMIT 1").get(`turn:${turn.id}`, event.seq);
     const handoffRow = this.db.prepare("SELECT data FROM events WHERE stream_id=? AND type='handoff.recorded' AND seq<? ORDER BY seq DESC LIMIT 1").get(`turn:${turn.id}`, event.seq);
-    if (!responseRow || !handoffRow || !handoffItem)
-      throw new Error(`turn event ${event.seq} completes a Goal without response and Handoff`);
-    const response = JSON.parse(responseRow.data);
+    if (!handoffRow || !handoffItem)
+      throw new Error(`turn event ${event.seq} completes a Goal without Handoff`);
     const handoff = JSON.parse(handoffRow.data);
-    const responseItem = responses.find((item) => item.id === response.messageItemId);
-    if (!responseItem || responseItem.data.text !== response.text || !isDeepStrictEqual(handoffItem.data, handoff))
-      throw new Error(`turn event ${event.seq} has mismatched response or Handoff facts`);
+    if (!isDeepStrictEqual(handoffItem.data, handoff))
+      throw new Error(`turn event ${event.seq} has mismatched Handoff facts`);
     assertHandoff(handoff);
     const record = this.workRecord(turn.goalId);
     if (handoff.goalId !== turn.goalId || handoff.goalRevision !== turn.goalRevision || record?.recordRevision !== handoff.recordRevision)

package/dist/{chunk-7E7V6OIU.js → chunk-EK6BTCFG.js}

@@ -124,18 +124,23 @@ var PiRunnerAdapter = class {
   }
   async #run(request) {
     const runnerSession = await this.driver.createRunnerSession(request);
+    let messageSequence = 0;
     try {
       while (true) {
         const step = await runnerSession.step();
         for (const trace of step.trace ?? [])
           request.emit(trace);
-        if (step.response)
-          return { outcome: "completed", response: step.response };
+        if (step.response) {
+          const finalMessageId = `adapter:${request.execution.id}:attempt:${request.execution.attempt}:message:${++messageSequence}`;
+          request.emit({ type: "message.assistant.completed", data: { message: { id: finalMessageId, role: "assistant", content: [{ type: "text", text: step.response.content }] }, commitState: "committed" } });
+          return { outcome: "completed", finalMessageId };
+        }
         if (step.handoff) {
-          const validation = await request.rpc?.("goal.handoff.validate", { handoff: step.handoff.handoff, candidateMessage: step.handoff.response.content });
+          const messageItemId = `adapter:${request.execution.id}:attempt:${request.execution.attempt}:message:${++messageSequence}`;
+          const validation = await request.rpc?.("goal.handoff.validate", { handoff: step.handoff.handoff, candidateMessageId: messageItemId, candidateMessage: step.handoff.response.content });
           if (!validation)
             return { outcome: "abnormal", reason: "Handoff validation is unavailable" };
-          request.emit({ type: "message.assistant.completed", data: { message: { id: `adapter:${request.execution.id}:handoff:${validation.attemptId}`, role: "assistant", content: [{ type: "text", text: step.handoff.response.content }], stopReason: "toolUse" }, commitState: "provisional" } });
+          request.emit({ type: "message.assistant.completed", data: { message: { id: messageItemId, role: "assistant", content: [{ type: "text", text: step.handoff.response.content }], stopReason: "toolUse" }, commitState: "provisional" } });
           if (!validation.accepted) {
             if (validation.fatal)
               return { outcome: "abnormal", reason: validation.issues.map((issue) => issue.message).join("; ") };
@@ -143,9 +148,11 @@ var PiRunnerAdapter = class {
             request.emit({ type: "runner.handoff_rejected", data: { attemptId: validation.attemptId, issues: validation.issues } });
             continue;
           }
+          if (validation.messageItemId !== messageItemId)
+            return { outcome: "abnormal", reason: "Handoff validation returned a different assistant message identity" };
           const output = { validationAttemptId: validation.attemptId, validationToken: validation.token, handoff: step.handoff.handoff };
           assertTurnOutput(output);
-          return { outcome: "completed", response: step.handoff.response, handoff: output };
+          return { outcome: "completed", finalMessageId: messageItemId, handoff: output };
         }
         if (step.stopped)
           return { outcome: "abnormal", reason: request.turn.goalCommitment ? "runner stopped without a readable response and valid handoff" : "runner stopped without a response" };

package/dist/{chunk-D2DVAH37.js → chunk-R6GKCNTB.js}

@@ -3,7 +3,7 @@ const require = __goahCreateRequire(import.meta.url);
 import {
   createPiProcessRunner,
   piRunnerConfigurator
-} from "./chunk-7E7V6OIU.js";
+} from "./chunk-EK6BTCFG.js";
 
 // node_modules/.dist-original/runner-registry.js
 var plugins = /* @__PURE__ */ new Map([

package/dist/{chunk-QBD6EJ2Z.js → chunk-SQJZ5OFH.js}

@@ -92,14 +92,20 @@ function field(value, key) {
 
 // node_modules/goah-supervisor/dist/roles.js
 var prompts = {
-  child: "Own the assigned Child Goal. Follow its observation method, verify completion with its verification method, inspect shared Work Records, cite Ledger evidence, update this Goal's Work Record every Turn, and hand off an explicit outcome. Handoff is declarative: use mail.send to notify or escalate, setting its typed goalId route to the parent Goal when it should wake the parent's next committed Turn; use schedule.set to request future motion and send a completion_proposed Mail when the parent should review completion. You are not a task-only worker and cannot redefine or complete your own Goal.",
-  ceo: `You are the user's sole operating interface and the durable CEO identity for this Goal tree. You organize work; you do not impersonate child execution.
+  child: `Own the assigned Child Goal. A Wake starts a work session; it is not a request for one short status update. Follow the observation method, verify completion with the verification method, inspect shared Work Records, cite Ledger evidence, and continue working while any safe, useful action can be executed now with current tools and authority. Use the Work Record as a durable checkpoint whenever the semantic state changes; updating it does not end the Turn. Planning, partial progress, or scheduling a future Wake are not by themselves reasons to stop. Before Handoff, ask whether another useful action can be completed without new authority, unavailable data, another Agent's result, or the passage of time; if yes, do it now.
+
+Handoff is declarative and ends this Turn. Use outcome progress only after meaningful work when the current actionable frontier is exhausted; waiting only for an explicit external condition; blocked only for a real obstacle; and completion_proposed only when the verification material is ready for parent review. Use mail.send to notify or escalate, setting its typed goalId route to the parent Goal when it should wake the parent's next committed Turn; use schedule.set for genuinely time-dependent future observation and send a completion_proposed Mail when the parent should review completion. You are not a task-only worker and cannot redefine or complete your own Goal.`,
+  ceo: `You are the user's sole operating interface and the durable CEO identity for this Goal tree. You organize work and execute directly wherever work is not delegated. You are the executor of last resort when no suitable Child Agent profile exists.
 
 On the first wake for a root with no observation method, operationalize the goal before claiming measurable progress: inspect the current directory with read/edit/write/bash; read project documentation, configuration, code, scripts, local CLIs, and existing ledger evidence; clarify the objective, constraints, baseline, and meaning of success; identify the data source or qualitative inspection protocol; define freshness, cadence, time zone, sustain window, and missing-data behavior when relevant; list the exact access required; then propose a textual observation method to the human. Ask only for facts or permissions that cannot be discovered locally. Continue safe reversible exploration while waiting. Never invent a baseline, data source, permission, success criterion, or observation result.
 
-On every wake: (1) orient from the root and descendants, each current observation method and revision, Team motion, incoming mail, handoffs, blockers, unknown Tool Calls, and recovery facts; (2) diagnose every active child's motion, ownership, and adherence to its authoritative observation method; (3) decide whether to keep, delegate, revise the objective/method pair, reassign, pause, resume, complete, or escalate; (4) apply organization changes only through the high-level atomic tools; (5) repair every idle_unplanned child and every child missing an observation method before handoff; (6) close with active child motion plus a CEO review, an explicit wait/blocker, a human request, or a completion recommendation carrying evidence produced under the current method.
+During every Goal Turn: (1) orient from the root and descendants, each current observation method and revision, Team motion, incoming mail, handoffs, blockers, unknown Tool Calls, and recovery facts; (2) diagnose every active child's motion, ownership, and adherence to its authoritative observation method; (3) decide whether to keep, delegate, revise the objective/method pair, reassign, pause, resume, complete, or escalate; (4) apply organization changes only through the high-level atomic tools; (5) repair every idle_unplanned child and every child missing an observation method; (6) execute the current work frontier instead of stopping at planning; (7) before ending, leave active child motion plus a CEO review, an explicit wait/blocker, a human request, or a completion recommendation carrying evidence produced under the current method.
+
+Use goal.delegate rather than separate goal/mail/schedule calls. Execute ambiguous or exploratory work yourself until a stream has a bounded objective, independent observation and verification methods, and a reviewable result; only then create a distinct Goal-owning Agent. If no suitable Child Agent profile exists, continue executing the work yourself rather than stopping after decomposition. Use team.list as the roster source of truth.
+
+A Wake starts a work session; it does not imply that the Turn should be short. Continue while any safe, useful action can be executed now with current tools and authority. Use the bound Goal's Work Record as a durable checkpoint whenever semantic state changes; updating it does not end the Turn. Planning, partial progress, decomposition, or scheduling a future Wake are not by themselves reasons to stop. Before Handoff, ask whether another useful action can be completed without new authority, unavailable data, another Agent's result, or the passage of time; if yes, do it now. Use outcome progress only when meaningful work is complete and the current actionable frontier is exhausted. Use waiting for an explicit external condition, blocked for a real obstacle, and completion_proposed only when verification material is ready for review.
 
-Use goal.delegate rather than separate goal/mail/schedule calls. Execute ambiguous or exploratory work yourself until a stream has a bounded objective, independent observation and verification methods, and a reviewable result; only then create a distinct Goal-owning Agent. Use team.list as the roster source of truth. Read the shared Work Record index, update the bound Goal's Work Record every Turn, and treat it as the durable semantic timeline. Handoff is declarative: use mail.send for explicit organization communication, schedule.set for future motion, and human.request when Human authority is required. Never claim authority to confirm Root methods, complete, or materially change a Root Goal: request the Human instead.`,
+Handoff is declarative and ends the Turn: use mail.send for explicit organization communication, schedule.set only for genuinely time-dependent future motion, and human.request when Human authority is required. Never claim authority to confirm Root methods, complete, or materially change a Root Goal: request the Human instead.`,
   verifier: "Verify one Turn's handoff claims against its trace and runner facts. Do not trust self-report. Persist concise findings with exact evidence sequences.",
   audit: "Independently reconstruct outcomes from durable facts and external observations. Persist independent audit judgment with memory_append; it never substitutes for fresh evidence."
 };
@@ -550,27 +556,18 @@ var Supervisor = class {
           this.#scheduleTurnRecovery(sourceWake, sourceWakeTriggers, current.id, agent);
           return;
         }
-        const response = normalizeAssistantText(result.response.content);
-        if (!response)
-          throw new Error("completed Turn requires a readable assistant response");
+        const responseItem = this.#finalAssistantItem(current.id, result.finalMessageId);
         if (turnContext.goalCommitment) {
           if (!result.handoff)
             throw new Error("committed Turn requires Handoff");
-          this.#commitTurnGoalWork(current.id, agent, turnContext, response, result.handoff, sourceWake?.id ?? null, deliveredMailIds, recordRevisionAtStart);
+          this.#commitTurnGoalWork(current.id, agent, turnContext, responseItem, result.handoff, sourceWake?.id ?? null, deliveredMailIds, recordRevisionAtStart);
           return;
         }
         if (result.handoff)
           throw new Error("uncommitted Turn cannot finish with Handoff");
-        const latestMessage = this.ledger.turnItems(current.id).findLast((item) => item.type === "assistant_message" && item.status === "completed");
-        if (latestMessage) {
-          const traced = normalizeAssistantText(String(latestMessage.data.text ?? ""));
-          if (traced !== response)
-            throw new Error("completed Turn response does not match its latest assistant trace");
-          if (this.#assistantCommitState(current.id, traced) !== "committed")
-            throw new Error("uncommitted Turn requires a committed assistant trace");
-        } else
-          this.#appendTurnItem(current.id, "assistant_message", { text: response }, agent);
-        this.ledger.finishTurn(current.id, "completed", null, this.#now(), "supervisor", deliveredMailIds);
+        if (this.#assistantCommitState(current.id, responseItem.id) !== "committed")
+          throw new Error("uncommitted Turn requires a committed assistant trace");
+        this.ledger.commitTurnResponse(current.id, responseItem.id, this.#now(), "supervisor", deliveredMailIds);
         return;
       } catch (error) {
         if (renewal)
@@ -727,19 +724,32 @@ ${history}` } : {} };
     const facts = this.ledger.readStream(`turn:${turnId}`).filter((event) => event.type === "turn.retry_started").map((event) => `${event.type}: ${JSON.stringify(event.data)}`);
     return [...items, ...facts].join("\n");
   }
-  #assistantCommitState(turnId, text) {
-    const canonical = normalizeAssistantText(text);
-    const event = this.ledger.readStream(`turn:${turnId}`).findLast((candidate) => {
+  #assistantMessageEvent(turnId, messageItemId) {
+    return this.ledger.readStream(`turn:${turnId}`).findLast((candidate) => {
       if (candidate.type !== "message.assistant.completed" || !candidate.data || typeof candidate.data !== "object" || Array.isArray(candidate.data))
         return false;
       const message = candidate.data.message;
-      return messageTextContent(message?.content) === canonical;
+      return message?.id === messageItemId;
     });
+  }
+  #assistantCommitState(turnId, messageItemId) {
+    const event = this.#assistantMessageEvent(turnId, messageItemId);
     if (!event || !event.data || typeof event.data !== "object" || Array.isArray(event.data))
       return null;
     const state = event.data.commitState;
     return state === "committed" || state === "provisional" ? state : null;
   }
+  #finalAssistantItem(turnId, messageItemId) {
+    const id = messageItemId.trim();
+    const item = id ? this.ledger.turnItems(turnId).find((candidate) => candidate.id === id) : void 0;
+    const text = item && item.type === "assistant_message" && item.status === "completed" ? normalizeAssistantText(String(item.data.text ?? "")) : "";
+    const event = id ? this.#assistantMessageEvent(turnId, id) : void 0;
+    const turn = this.ledger.turn(turnId);
+    const retryStart = turn && turn.attempt > 1 ? this.ledger.readStream(`turn:${turnId}`).findLast((candidate) => candidate.type === "turn.retry_started" && candidate.data.attempt === turn.attempt) : void 0;
+    if (!item || !text || !event || retryStart && event.seq <= retryStart.seq)
+      throw new Error("completed Turn finalMessageId must reference a readable Assistant Item from the current attempt");
+    return item;
+  }
   #failTurn(turnId, reason) {
     const current = this.ledger.turn(turnId);
     if (!current || current.status !== "in_progress")
@@ -826,8 +836,12 @@ ${history}` } : {} };
     if (type === "message.assistant.completed") {
       const value = data;
       const text = messageTextContent(value.message?.content);
-      if (text)
-        this.#appendTurnItem(turnId, "assistant_message", { text }, actor);
+      if (text) {
+        const id = typeof value.message?.id === "string" ? value.message.id.trim() : "";
+        if (!id)
+          throw new Error("Runner assistant completion is missing a message Item id");
+        this.#appendTurnItem(turnId, "assistant_message", { text }, actor, id);
+      }
     } else if (type === "plan.updated")
       this.#appendTurnItem(turnId, "plan", data, actor);
     else if (type === "message.assistant.delta") {
@@ -1195,7 +1209,7 @@ ${history}` } : {} };
       return agent === "ceo" && role === "ceo";
     return role === "verifier" || role === "audit";
   }
-  #commitTurnGoalWork(turnId, agent, turn, response, raw, sourceWakeId, mailIds, revisionAtStart) {
+  #commitTurnGoalWork(turnId, agent, turn, responseItem, raw, sourceWakeId, mailIds, revisionAtStart) {
     const binding = turn.goalCommitment;
     const goal = this.#goal(binding.goalId);
     if (goal.revision !== binding.goalRevision)
@@ -1206,11 +1220,9 @@ ${history}` } : {} };
     assertTurnOutput(raw);
     const validation = this.#handoffValidations.get(raw.validationToken);
     const execution = this.ledger.turn(turnId);
-    if (!validation || !execution || validation.turnId !== turnId || validation.attemptId !== raw.validationAttemptId || this.#handoffAttemptSeq.get(turnId) !== raw.validationAttemptId || validation.agent !== agent || validation.attempt !== execution.attempt || validation.leaseToken !== execution.leaseToken || validation.goalId !== goal.id || validation.goalRevision !== goal.revision || validation.message !== response || validation.handoff.outcome !== raw.handoff.outcome || !isSameNumbers(validation.handoff.evidence, raw.handoff.evidence))
+    const response = normalizeAssistantText(String(responseItem.data.text ?? ""));
+    if (!validation || !execution || validation.turnId !== turnId || validation.attemptId !== raw.validationAttemptId || this.#handoffAttemptSeq.get(turnId) !== raw.validationAttemptId || validation.agent !== agent || validation.attempt !== execution.attempt || validation.leaseToken !== execution.leaseToken || validation.goalId !== goal.id || validation.goalRevision !== goal.revision || validation.messageItemId !== responseItem.id || validation.message !== response || validation.handoff.outcome !== raw.handoff.outcome || !isSameNumbers(validation.handoff.evidence, raw.handoff.evidence))
       throw new Error("Handoff validation token is stale or does not match this Turn result");
-    const responseItem = [...this.ledger.turnItems(turnId)].reverse().find((item2) => item2.type === "assistant_message" && item2.status === "completed" && item2.data.text === validation.message);
-    if (!responseItem)
-      throw new Error("accepted Handoff response was not recorded in the Turn");
     const output = this.#committedTurnOutput(raw, binding);
     assertHandoff(output.handoff);
     const now = this.#now();
@@ -1341,7 +1353,8 @@ ${workText}`, activeGoal: turn.activeGoal, goalCommitment: turn.goalCommitment,
     const input = asRecord(params);
     if (method === "goal.handoff.validate") {
       const candidate = String(input.candidateMessage ?? "");
-      this.ledger.appendEvent({ streamId: `turn:${turnId}`, ts: this.#now(), actor: agent, type: "rpc.goal.handoff.validate", data: { attemptId: handoffAttemptId, handoff: input.handoff ?? null, candidateMessagePresent: Boolean(candidate.trim()), candidateMessageChars: candidate.length }, ignorable: true });
+      const candidateMessageId = String(input.candidateMessageId ?? "");
+      this.ledger.appendEvent({ streamId: `turn:${turnId}`, ts: this.#now(), actor: agent, type: "rpc.goal.handoff.validate", data: { attemptId: handoffAttemptId, handoff: input.handoff ?? null, candidateMessageId, candidateMessagePresent: Boolean(candidate.trim()), candidateMessageChars: candidate.length }, ignorable: true });
       return this.#validateHandoffDraft(turnId, handoffAttemptId, agent, execution, context, input);
     }
     const profile = this.#profiles.get(agent) ?? { agent, role: "child" };
@@ -1480,17 +1493,19 @@ ${workText}`, activeGoal: turn.activeGoal, goalCommitment: turn.goalCommitment,
   #validateHandoffDraft(turnId, attemptId, agent, execution, context, input) {
     if (!context.goalCommitment || execution.goalId === null)
       return { accepted: false, fatal: true, attemptId, issues: [{ code: "turn_not_committed", message: "This Turn no longer has a Goal commitment." }] };
-    const request = { handoff: input.handoff ?? null, candidateMessage: String(input.candidateMessage ?? "") };
+    const request = { handoff: input.handoff ?? null, candidateMessageId: String(input.candidateMessageId ?? "").trim(), candidateMessage: String(input.candidateMessage ?? "") };
     const issues = [];
     try {
       assertAgentHandoff(request.handoff);
     } catch {
       issues.push({ code: "handoff_invalid", message: "Handoff requires a valid outcome and at least one evidence event." });
     }
-    const existingMessage = [...this.ledger.turnItems(turnId)].reverse().find((item) => item.type === "assistant_message" && item.status === "completed" && typeof item.data.text === "string" && Boolean(item.data.text.trim()));
-    const message = normalizeAssistantText(request.candidateMessage) || normalizeAssistantText(String(existingMessage?.data?.text ?? ""));
-    if (!message)
-      issues.push({ code: "message_missing", message: "This committed Turn needs a readable assistant message before it can finish." });
+    const message = normalizeAssistantText(request.candidateMessage);
+    const existingMessage = request.candidateMessageId ? this.ledger.turnItems(turnId).find((item) => item.id === request.candidateMessageId) : void 0;
+    if (!request.candidateMessageId || !message)
+      issues.push({ code: "message_missing", message: "This committed Turn needs a readable assistant message Item before it can finish." });
+    else if (existingMessage && (existingMessage.type !== "assistant_message" || existingMessage.status !== "completed" || normalizeAssistantText(String(existingMessage.data.text ?? "")) !== message))
+      issues.push({ code: "message_mismatch", message: "Handoff message identity does not match its assistant Item." });
     const goal = this.ledger.goal(context.goalCommitment.goalId);
     if (!goal || goal.phase !== "active" || goal.owner !== agent || goal.revision !== context.goalCommitment.goalRevision)
       return { accepted: false, fatal: true, attemptId, issues: [{ code: "goal_fence_changed", message: "Goal ownership, phase, or revision changed; this Turn can no longer finish against the old commitment." }] };
@@ -1504,8 +1519,8 @@ ${workText}`, activeGoal: turn.activeGoal, goalCommitment: turn.goalCommitment,
     if (issues.length)
       return { accepted: false, fatal: false, attemptId, issues };
     const token = randomUUID();
-    this.#handoffValidations.set(token, { turnId, attemptId, agent, attempt: execution.attempt, leaseToken: execution.leaseToken, goalId: goal.id, goalRevision: goal.revision, message, handoff: { outcome: request.handoff.outcome, evidence: [...request.handoff.evidence] } });
-    return { accepted: true, fatal: false, attemptId, token, goalId: goal.id, goalRevision: goal.revision };
+    this.#handoffValidations.set(token, { turnId, attemptId, agent, attempt: execution.attempt, leaseToken: execution.leaseToken, goalId: goal.id, goalRevision: goal.revision, messageItemId: request.candidateMessageId, message, handoff: { outcome: request.handoff.outcome, evidence: [...request.handoff.evidence] } });
+    return { accepted: true, fatal: false, attemptId, token, goalId: goal.id, goalRevision: goal.revision, messageItemId: request.candidateMessageId };
   }
   #beginHandoffAttempt(turnId) {
     this.#invalidateHandoffTokens(turnId);

package/dist/cli.js

@@ -25,14 +25,14 @@ import {
   streamEvents,
   updateWorkspaceRunnerProfile,
   writeDefaultConfig
-} from "./chunk-KJ4HJCTK.js";
+} from "./chunk-5PZFP5CO.js";
 import {
   runnerManifests,
   runnerPlugin
-} from "./chunk-D2DVAH37.js";
-import "./chunk-YH6YJ2IB.js";
-import "./chunk-QBD6EJ2Z.js";
-import "./chunk-7E7V6OIU.js";
+} from "./chunk-R6GKCNTB.js";
+import "./chunk-CDELLMIJ.js";
+import "./chunk-SQJZ5OFH.js";
+import "./chunk-EK6BTCFG.js";
 import "./chunk-6M3OOCKO.js";
 import "./chunk-K26BVR6O.js";
 import "./chunk-IIJQ3DW4.js";
@@ -12670,6 +12670,9 @@ var ConversationView = class {
     this.entries.push({ kind: "component", component });
   }
   addText(content) {
+    const previous = this.entries.at(-1);
+    if (previous?.kind === "text" && previous.content === content)
+      return;
     this.entries.push({ kind: "text", content });
     this.trim();
   }
@@ -12677,15 +12680,17 @@ var ConversationView = class {
     this.entries.push({ kind: "user", content });
     this.trim();
   }
-  addMarkdown(content) {
+  addMarkdown(content, messageId) {
     this.liveMarkdown = "";
     content = content.trim();
     if (!content)
       return;
+    if (messageId && this.entries.some((entry) => entry.kind === "markdown" && entry.messageId === messageId))
+      return;
     const previous = this.entries.at(-1);
     if (previous?.kind === "markdown" && previous.content === content)
       return;
-    this.entries.push({ kind: "markdown", content });
+    this.entries.push({ kind: "markdown", content, ...messageId ? { messageId } : {} });
     this.trim();
   }
   appendLiveMarkdown(content) {
@@ -12990,14 +12995,14 @@ async function runGoahTui(configPath, stateDir, initialMessage) {
     transcriptView.appendLiveMarkdown(text);
     tui.requestRender();
   };
-  const commitLive = (text) => {
+  const commitLive = (text, messageId) => {
     transcriptView.clearLiveMarkdown();
     if (text)
-      transcriptView.addMarkdown(text);
+      transcriptView.addMarkdown(text, messageId);
     tui.requestRender();
   };
-  const pushResponse = (text) => {
-    transcriptView.addMarkdown(text);
+  const pushResponse = (text, messageId) => {
+    transcriptView.addMarkdown(text, messageId);
     tui.requestRender();
   };
   const updateTool = (activity) => {
@@ -13457,15 +13462,16 @@ function renderFrame(frame, push, appendLive = push, commitLive = push, pushResp
       return;
     }
     const text = messageText(message.content);
+    const messageId = typeof message.id === "string" ? message.id : void 0;
     if (data.commitState === "provisional") {
       clearLive();
       return;
     }
     if (text)
-      commitLive(text);
+      commitLive(text, messageId);
   } else if (record.type === "response.committed") {
     if (typeof data.text === "string" && data.text.trim())
-      commitLive(data.text.trim());
+      commitLive(data.text.trim(), typeof data.messageItemId === "string" ? data.messageItemId : void 0);
   } else if (record.type === "handoff.recorded") {
     if (typeof data.goalId === "string")
       push(`${data.outcome === "blocked" ? tuiTheme.error("goal blocked") : tuiTheme.success("goal saved")}  ${tuiTheme.muted(`${String(data.outcome).replaceAll("_", " ")} \xB7 record r${String(data.recordRevision)}`)}`);
@@ -13955,7 +13961,7 @@ async function main() {
       console.log(JSON.stringify({ goal }, null, 2));
     } else if (command === "dashboard") {
       const path4 = option("--output") ?? join7(config.stateDir, "status.html");
-      writeFileSync(path4, (await import("./dist-KNR2XL6J.js")).renderDashboard(ledger));
+      writeFileSync(path4, (await import("./dist-QW77PKUJ.js")).renderDashboard(ledger));
       console.log(path4);
     } else
       throw new Error(`unknown command: ${command}`);
@@ -13965,7 +13971,7 @@ async function main() {
   }
 }
 async function run(supervisor, signal) {
-  const { runSupervisorDaemon } = await import("./dist-KNR2XL6J.js");
+  const { runSupervisorDaemon } = await import("./dist-QW77PKUJ.js");
   await runSupervisorDaemon(supervisor, { signal });
 }
 async function waitForConsole(stateDir) {
@@ -14200,7 +14206,7 @@ async function runRunnerCommand(command, commandArgs, configPath) {
 async function runRunnerEarly(configPath) {
   const action = args[1] ?? "list";
   if (action === "list") {
-    for (const manifest of (await import("./runner-registry-GD4BYCQC.js")).runnerManifests())
+    for (const manifest of (await import("./runner-registry-3WSOMXRW.js")).runnerManifests())
       console.log(`${manifest.id.padEnd(16)} ${manifest.description}`);
     return;
   }

package/dist/{dist-KNR2XL6J.js → dist-QW77PKUJ.js}

@@ -15,7 +15,7 @@ import {
   renderDashboard,
   runSupervisorDaemon,
   selectRecoveryEvents
-} from "./chunk-QBD6EJ2Z.js";
+} from "./chunk-SQJZ5OFH.js";
 import "./chunk-4KA63VNZ.js";
 import "./chunk-KAO7WIXG.js";
 import "./chunk-R6I3VKME.js";

package/dist/execution.d.ts

@@ -304,6 +304,7 @@ type HandoffValidationResult = {
     token: string;
     goalId: string;
     goalRevision: number;
+    messageItemId: string;
 } | {
     accepted: false;
     fatal: boolean;
@@ -312,6 +313,7 @@ type HandoffValidationResult = {
 };
 interface HandoffValidationRequest {
     handoff: AgentHandoff;
+    candidateMessageId: string;
     candidateMessage: string;
 }
 interface TurnOutput {
@@ -418,9 +420,6 @@ interface TurnContext {
     activeGoal: GoalSnapshot | null;
     goalCommitment: GoalCommitment | null;
 }
-interface AssistantResponse {
-    content: string;
-}
 /** Canonical user-visible assistant prose. Raw provider events remain unchanged. */
 declare function normalizeAssistantText(text: string): string;
 interface RunRequest {
@@ -436,7 +435,7 @@ interface RunRequest {
 }
 type RunnerCandidateResult = {
     outcome: "completed";
-    response: AssistantResponse;
+    finalMessageId: string;
     handoff?: TurnOutput;
 } | {
     outcome: "abnormal";
@@ -514,7 +513,8 @@ interface Ledger extends EventStore {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mail: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];
@@ -554,4 +554,4 @@ declare function assertTurnOutput(value: TurnOutput): void;
 declare function assertGoalSnapshot(value: GoalSnapshot): void;
 
 export { assertAgentHandoff, assertGoalSnapshot, assertGoalTransition, assertHandoff, assertTurnOutput, assertWakeTransition, goalAutomaticTarget, goalCommitment, goalRoute, humanInboxRoute, humanRequestRoute, noGoalCommitment, normalizeAssistantText, specialistAutomaticTarget, specialistInboxRoute };
-export type { AgentCapability, AgentHandoff, AgentProfile, AgentRole, AssistantResponse, AutomaticTarget, CommittedTurnOutput, DelegationRequest, DelegationResult, GoalChangeAuthority, GoalChangeMetadata, GoalChangeOperation, GoalChangedData, GoalCommitment, GoalCompletionRequest, GoalHandoff, GoalOutcome, GoalPhase, GoalSnapshot, Handoff, HandoffCommit, HandoffValidationIssue, HandoffValidationRequest, HandoffValidationResult, HumanTurnAdmissionRequest, HumanTurnAdmissionResult, Ledger, MailLevel, MailRoute, MailSnapshot, ReassignmentRequest, ReassignmentResult, RunRequest, Runner, RunnerCandidateResult, RunnerChoice, RunnerCommandResult, RunnerConfigurator, RunnerControlMethod, RunnerDiagnostic, RunnerHandle, RunnerManifest, RunnerProfile, RunnerRpcMethod, RunnerSetupInteraction, RunnerSetupProgress, RunnerSetupTransaction, RunnerTraceEvent, ScheduleSnapshot, ScheduleStatus, SpecialistRole, TeamMemberMotion, TeamMemberView, ThreadSnapshot, TurnContext, TurnItemSnapshot, TurnItemStatus, TurnItemType, TurnOutput, TurnSnapshot, TurnStatus, TurnTrigger, TurnTriggerKind, WakeSnapshot, WakeStatus, WakeTriggerSnapshot, WakeTriggerStatus, WorkRecordDiff, WorkRecordSnapshot, WorkRecordUpdateRequest };
+export type { AgentCapability, AgentHandoff, AgentProfile, AgentRole, AutomaticTarget, CommittedTurnOutput, DelegationRequest, DelegationResult, GoalChangeAuthority, GoalChangeMetadata, GoalChangeOperation, GoalChangedData, GoalCommitment, GoalCompletionRequest, GoalHandoff, GoalOutcome, GoalPhase, GoalSnapshot, Handoff, HandoffCommit, HandoffValidationIssue, HandoffValidationRequest, HandoffValidationResult, HumanTurnAdmissionRequest, HumanTurnAdmissionResult, Ledger, MailLevel, MailRoute, MailSnapshot, ReassignmentRequest, ReassignmentResult, RunRequest, Runner, RunnerCandidateResult, RunnerChoice, RunnerCommandResult, RunnerConfigurator, RunnerControlMethod, RunnerDiagnostic, RunnerHandle, RunnerManifest, RunnerProfile, RunnerRpcMethod, RunnerSetupInteraction, RunnerSetupProgress, RunnerSetupTransaction, RunnerTraceEvent, ScheduleSnapshot, ScheduleStatus, SpecialistRole, TeamMemberMotion, TeamMemberView, ThreadSnapshot, TurnContext, TurnItemSnapshot, TurnItemStatus, TurnItemType, TurnOutput, TurnSnapshot, TurnStatus, TurnTrigger, TurnTriggerKind, WakeSnapshot, WakeStatus, WakeTriggerSnapshot, WakeTriggerStatus, WorkRecordDiff, WorkRecordSnapshot, WorkRecordUpdateRequest };

package/dist/faux-runner-worker.js

@@ -2,7 +2,7 @@ import { createRequire as __goahCreateRequire } from "node:module";
 const require = __goahCreateRequire(import.meta.url);
 import {
   runProcessWorker
-} from "./chunk-7E7V6OIU.js";
+} from "./chunk-EK6BTCFG.js";
 import "./chunk-6M3OOCKO.js";
 import "./chunk-K26BVR6O.js";
 import "./chunk-IIJQ3DW4.js";
@@ -32,6 +32,7 @@ await runProcessWorker(async (request, emit, rpc) => {
   const steps = triggerSteps ?? byAgent[request.agent] ?? JSON.parse(process.env.GOAH_FAUX_STEPS ?? "[]");
   let goalCommitment = request.turn?.goalCommitment;
   let recordUpdated = false;
+  let messageSequence = 0;
   for (const step of steps) {
     if (step.write) {
       const path = join(process.cwd(), step.write.path);
@@ -54,8 +55,11 @@ await runProcessWorker(async (request, emit, rpc) => {
       await new Promise((resolve) => setTimeout(resolve, step.delayMs));
     if (step.hang)
       await new Promise(() => void 0);
-    if (step.response !== void 0)
-      return { outcome: "completed", response: { content: step.response } };
+    if (step.response !== void 0) {
+      const finalMessageId = `faux:${request.execution.id}:attempt:${request.execution.attempt}:message:${++messageSequence}`;
+      emit({ type: "message.assistant.completed", data: { message: { id: finalMessageId, role: "assistant", content: [{ type: "text", text: step.response }] }, commitState: "committed" } });
+      return { outcome: "completed", finalMessageId };
+    }
     if (step.handoff) {
       const draft = step.handoff;
       if (goalCommitment && !recordUpdated) {
@@ -64,16 +68,19 @@ await runProcessWorker(async (request, emit, rpc) => {
         const evidence = sourceSeqs(request.context);
         await rpc("work_record.update", { expectedRevision: Number(record.recordRevision ?? 0), content: handoffRecord(draft.handoff, request.execution.id), reason: "record faux Goal progress", evidence: evidence.length ? [Math.max(...evidence)] : [] });
       }
-      const validation = await rpc("goal.handoff.validate", { handoff: draft.handoff, candidateMessage: draft.response.content });
-      emit({ type: "message.assistant.completed", data: { message: { id: `faux:${request.execution.id}:handoff:${validation.attemptId}`, role: "assistant", content: [{ type: "text", text: draft.response.content }], stopReason: "toolUse" }, commitState: "provisional" } });
+      const messageItemId = `faux:${request.execution.id}:attempt:${request.execution.attempt}:message:${++messageSequence}`;
+      const validation = await rpc("goal.handoff.validate", { handoff: draft.handoff, candidateMessageId: messageItemId, candidateMessage: draft.response.content });
+      emit({ type: "message.assistant.completed", data: { message: { id: messageItemId, role: "assistant", content: [{ type: "text", text: draft.response.content }], stopReason: "toolUse" }, commitState: "provisional" } });
       if (!validation.accepted) {
         emit({ type: "runner.handoff_rejected", data: { attemptId: validation.attemptId, issues: validation.issues } });
         if (validation.fatal)
           return { outcome: "abnormal", reason: validation.issues.map((issue) => issue.message).join("; ") };
         continue;
       }
+      if (validation.messageItemId !== messageItemId)
+        return { outcome: "abnormal", reason: "Handoff validation returned a different assistant message identity" };
       const output = { validationAttemptId: validation.attemptId, validationToken: validation.token, handoff: draft.handoff };
-      return { outcome: "completed", response: draft.response, handoff: output };
+      return { outcome: "completed", finalMessageId: messageItemId, handoff: output };
     }
   }
   return { outcome: "abnormal", reason: "faux worker stopped without handoff" };

package/dist/index.d.ts

@@ -337,9 +337,6 @@ interface TurnContext {
     activeGoal: GoalSnapshot | null;
     goalCommitment: GoalCommitment | null;
 }
-interface AssistantResponse {
-    content: string;
-}
 interface RunRequest {
     agent: string;
     execution: TurnSnapshot;
@@ -353,7 +350,7 @@ interface RunRequest {
 }
 type RunnerCandidateResult = {
     outcome: "completed";
-    response: AssistantResponse;
+    finalMessageId: string;
     handoff?: TurnOutput;
 } | {
     outcome: "abnormal";
@@ -431,7 +428,8 @@ interface Ledger extends EventStore {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mail: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];
@@ -518,7 +516,8 @@ declare class SqliteLedger implements Ledger {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mails: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];

package/dist/index.js

@@ -31,11 +31,11 @@ import {
   updateWorkspaceRunnerProfile,
   writeDefaultConfig,
   writeDefaultRunnerProfile
-} from "./chunk-KJ4HJCTK.js";
-import "./chunk-D2DVAH37.js";
-import "./chunk-YH6YJ2IB.js";
-import "./chunk-QBD6EJ2Z.js";
-import "./chunk-7E7V6OIU.js";
+} from "./chunk-5PZFP5CO.js";
+import "./chunk-R6GKCNTB.js";
+import "./chunk-CDELLMIJ.js";
+import "./chunk-SQJZ5OFH.js";
+import "./chunk-EK6BTCFG.js";
 import "./chunk-6M3OOCKO.js";
 import "./chunk-K26BVR6O.js";
 import "./chunk-IIJQ3DW4.js";

package/dist/pi-worker.js

@@ -5,7 +5,7 @@ import {
 } from "./chunk-XALZLRYK.js";
 import {
   runProcessWorker
-} from "./chunk-7E7V6OIU.js";
+} from "./chunk-EK6BTCFG.js";
 import {
   createPiModel,
   fauxAssistantMessage,
@@ -35,6 +35,9 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { delimiter, dirname, join, resolve, sep } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
+var GOAL_TURN_POLICY = `A Goal commitment starts a sustained work session, not a short status round. Continue working while any safe, useful action can be executed now with current tools and authority. Use the Work Record as a durable checkpoint whenever the semantic state changes; updating it does not end the Turn. Planning, partial progress, decomposition, or scheduling a future Wake are not by themselves reasons to stop. Before Handoff, ask whether another useful action can be completed without new authority, unavailable data, another Agent's result, or the passage of time; if yes, do it now.
+
+Call handoff exactly once, only at a genuine control boundary: the current actionable frontier is exhausted after meaningful work, an explicit external wait is required, a real blocker prevents safe progress, or completion evidence is ready for review. Use outcome progress only for the first case, waiting only for the second, blocked only for the third, and completion_proposed only for the fourth. Write a concise human-readable assistant message describing what happened, and keep Handoff machine-readable with only outcome and evidence. Treat the supplied context as authoritative.`;
 function compactMessages(messages, maxRecent = 8) {
   if (messages.length <= maxRecent + 1)
     return messages;
@@ -100,8 +103,10 @@ Follow the current Goal and explicit tools.
 `;
         const finalResponse = fauxAssistantMessage([fauxText(String(handoff.message ?? `Goal work recorded with outcome ${outcome}.`)), fauxToolCall("handoff", { outcome, evidence: handoffEvidence })], { stopReason: "toolUse" });
         const recordResponse = fauxAssistantMessage(fauxToolCall("work_record_update", { expectedRevision: Number(current.recordRevision ?? 0), content: record, reason: "record faux Goal progress", evidence: evidence.length ? [Math.max(...evidence)] : [] }), { stopReason: "toolUse" });
+        const narratedScheduleResponse = fauxAssistantMessage([fauxText(String(handoff.message ?? "Work Record updated; the next wake is scheduled.")), fauxToolCall("schedule_wake", { at: new Date(Date.parse(request.execution.startedAt) + 6e4).toISOString(), reason: "continue Goal work" })], { stopReason: "toolUse" });
+        const toolOnlyHandoff = fauxAssistantMessage(fauxToolCall("handoff", { outcome, evidence: handoffEvidence }), { stopReason: "toolUse" });
         const fatalBatch = fauxAssistantMessage([fauxText("Stale completion attempt."), fauxToolCall("handoff", { outcome, evidence: handoffEvidence }), fauxToolCall("write", { path: "fatal.txt", content: "must not be written" })], { stopReason: "toolUse" });
-        faux.setResponses(process.env.GOAH_PI_FAUX_FATAL_BATCH === "1" ? [fatalBatch] : process.env.GOAH_PI_FAUX_HANDOFF_REPAIR === "1" ? [fauxAssistantMessage([fauxText("Premature completion attempt."), fauxToolCall("handoff", { outcome, evidence: handoffEvidence })], { stopReason: "toolUse" }), recordResponse, finalResponse] : [recordResponse, finalResponse]);
+        faux.setResponses(process.env.GOAH_PI_FAUX_FATAL_BATCH === "1" ? [fatalBatch] : process.env.GOAH_PI_FAUX_HANDOFF_REPAIR === "1" ? [fauxAssistantMessage([fauxText("Premature completion attempt."), fauxToolCall("handoff", { outcome, evidence: handoffEvidence })], { stopReason: "toolUse" }), recordResponse, finalResponse] : process.env.GOAH_PI_FAUX_TOOL_ONLY_HANDOFF === "1" ? [recordResponse, narratedScheduleResponse, toolOnlyHandoff] : [recordResponse, finalResponse]);
       } else if (!goalState.bound) {
         faux.setResponses([fauxAssistantMessage([fauxText(process.env.GOAH_PI_FAUX_RESPONSE ?? "Hello from Goah.")])]);
       } else {
@@ -113,7 +118,7 @@ Follow the current Goal and explicit tools.
     let output = null;
     let acceptedHandoff = null;
     let revokedReason = "";
-    let response = "";
+    let lastReadableMessage = null;
     let responseFailure = "";
     let compactions = 0;
     let messageCounter = 0;
@@ -125,7 +130,7 @@ Follow the current Goal and explicit tools.
       const existing = messageIds.get(message);
       if (existing)
         return existing;
-      const id = `message:${++messageCounter}`;
+      const id = `${request.execution.id}:attempt:${request.execution.attempt}:message:${++messageCounter}`;
       messageIds.set(message, id);
       return id;
     };
@@ -145,8 +150,11 @@ Follow the current Goal and explicit tools.
     const sourceSeqs = Array.isArray(contextRecord.sourceSeqs) ? contextRecord.sourceSeqs.filter((value) => Number.isInteger(value)) : [];
     const basePrompt = process.env.GOAH_PI_SYSTEM_PROMPT ?? suppliedPrompt ?? (request.turn?.trigger.kind === "user_message" ? "You are Goah's primary Agent. Respond naturally to the Human." : `You are Goah Agent ${request.agent}. Inspect the supplied context and respond appropriately.`);
     const systemPrompt = goalState.bound ? `${basePrompt}
-This Turn has a Goal commitment. You must update its Work Record, write a concise human-readable assistant message describing what happened, and call handoff exactly once with only machine-readable outcome and evidence. The message and Handoff are separate outputs. Treat the supplied context as authoritative.` : request.turn?.trigger.kind === "user_message" ? `${basePrompt}
-The active Goal, when supplied, is context rather than an assignment. Finish with an ordinary response unless a Goal tool establishes a commitment during this Turn. After commitment, update that Goal's Work Record, write a concise human-readable assistant message, and call handoff exactly once with separate machine-readable outcome and evidence. Treat the supplied context as authoritative.` : `${basePrompt}
+
+${GOAL_TURN_POLICY}` : request.turn?.trigger.kind === "user_message" ? `${basePrompt}
+The active Goal, when supplied, is context rather than an assignment. Finish with an ordinary response unless a Goal tool establishes a commitment during this Turn. If a Goal commitment is established, follow this policy for the rest of the Turn:
+
+${GOAL_TURN_POLICY}` : `${basePrompt}
 This Turn has no Goal commitment. Finish with an ordinary response and do not call handoff. Treat the supplied context as authoritative.`;
     const agent = new Agent({
       initialState: {
@@ -196,10 +204,16 @@ This Turn has no Goal commitment. Finish with an ordinary response and do not ca
         acceptedHandoff = null;
         output = null;
         const handoff = args;
+        const currentText = assistantResponseText(assistantMessage);
+        const candidate = currentText ? { id: idFor(assistantMessage), text: currentText } : lastReadableMessage;
         try {
-          const result = await rpc("goal.handoff.validate", { handoff, candidateMessage: assistantResponseText(assistantMessage) });
+          const result = await rpc("goal.handoff.validate", { handoff, candidateMessageId: candidate?.id ?? "", candidateMessage: candidate?.text ?? "" });
           if (result.accepted) {
-            acceptedHandoff = { attemptId: result.attemptId, token: result.token, handoff };
+            if (!candidate || result.messageItemId !== candidate.id) {
+              revokedReason = "Handoff validation returned a different assistant message identity";
+              return { block: true, reason: revokedReason, terminate: true };
+            }
+            acceptedHandoff = { attemptId: result.attemptId, token: result.token, messageItemId: result.messageItemId, handoff };
             return;
           }
           const reason = result.issues.map((issue) => `- ${issue.message}`).join("\n");
@@ -234,11 +248,14 @@ ${reason}`, terminate: result.fatal };
       } else if (event.type === "message_update") {
         emit({ type: "message.assistant.delta", data: { messageId: idFor(event.message), delta: JSON.parse(JSON.stringify(event.assistantMessageEvent)) } });
       } else if (event.type === "message_end" && event.message.role === "assistant") {
-        response = assistantResponseText(event.message);
+        const messageId = idFor(event.message);
+        const text = assistantResponseText(event.message);
+        if (text)
+          lastReadableMessage = { id: messageId, text };
         if ((event.message.stopReason === "error" || event.message.stopReason === "aborted") && event.message.errorMessage)
           responseFailure = event.message.errorMessage;
         const handoffIntent = hasAgentToolCall(event.message, "handoff");
-        emit({ type: "message.assistant.completed", data: { message: transcriptMessage(event.message, idFor(event.message)), commitState: handoffIntent ? "provisional" : "committed" } });
+        emit({ type: "message.assistant.completed", data: { message: transcriptMessage(event.message, messageId), commitState: handoffIntent ? "provisional" : "committed" } });
       } else if (event.type === "tool_execution_start")
         emit({ type: "tool.called", data: { callId: event.toolCallId, name: event.toolName, arguments: JSON.parse(JSON.stringify(event.args)) } });
       else if (event.type === "tool_execution_end")
@@ -262,13 +279,17 @@ Runner root: ${root}. Manage local files directly when the goal requires them.`)
     }
     if (revokedReason)
       return { outcome: "abnormal", reason: revokedReason };
+    const finalMessage = lastReadableMessage;
     if (!goalState.bound)
-      return response ? { outcome: "completed", response: { content: response } } : { outcome: "abnormal", reason: responseFailure || "Pi worker exited without a response" };
+      return finalMessage ? { outcome: "completed", finalMessageId: finalMessage.id } : { outcome: "abnormal", reason: responseFailure || "Pi worker exited without a response" };
     if (responseFailure)
       return { outcome: "abnormal", reason: responseFailure };
     if (!output)
       return { outcome: "abnormal", reason: "Pi worker exited without an accepted Handoff" };
-    return { outcome: "completed", response: { content: response }, handoff: output };
+    const finalHandoff = acceptedHandoff;
+    if (!finalHandoff)
+      return { outcome: "abnormal", reason: "Pi worker exited without an accepted Handoff message" };
+    return { outcome: "completed", finalMessageId: finalHandoff.messageItemId, handoff: output };
   });
 }
 function snapshotModelConfig(options) {
@@ -294,7 +315,7 @@ function createTools(root, handoff, rpc, capabilities, goalState, protectedPaths
   const handoffTool = {
     name: "handoff",
     label: "Handoff",
-    description: "Record a structured handoff and end a Turn with a Goal commitment.",
+    description: "End the current Goal Turn at a genuine control boundary. Do not call while another safe and useful action can be completed now. Planning, partial progress, a Work Record update, or a scheduled Wake does not by itself justify Handoff.",
     parameters: typebox_exports.Object({
       outcome: typebox_exports.Union([typebox_exports.Literal("progress"), typebox_exports.Literal("waiting"), typebox_exports.Literal("blocked"), typebox_exports.Literal("completion_proposed")]),
       evidence: typebox_exports.Array(typebox_exports.Number())
@@ -488,7 +509,7 @@ function createRpcTools(rpc, allowed, onResult) {
     ["ledger.search", tool("ledger_search", "Search durable ledger facts.", "ledger.search", typebox_exports.Object({ query: typebox_exports.String(), limit: typebox_exports.Optional(typebox_exports.Number()) }))],
     ["memory.append", tool("memory_append", "Append a durable working-memory note that is injected into your future wakes. Record procedural knowledge, active hypotheses, and abandoned approaches with the reason; keep notes concise.", "memory.append", typebox_exports.Object({ note: typebox_exports.String() }))],
     ["mail.send", tool("send_mail", "Send durable Mail to another Goal owner. goalId is required and routes the Mail into that owner's next committed Turn. Human communication must use request_human.", "mail.send", typebox_exports.Object({ to: typebox_exports.String(), goalId: typebox_exports.String(), level: typebox_exports.Union([typebox_exports.Literal("fyi"), typebox_exports.Literal("decision"), typebox_exports.Literal("emergency")]), body: typebox_exports.Any() }))],
-    ["schedule.set", tool("schedule_wake", "Schedule this agent's next wake.", "schedule.set", typebox_exports.Object({ at: typebox_exports.String(), reason: typebox_exports.String() }))],
+    ["schedule.set", tool("schedule_wake", "Schedule genuinely time-dependent future observation. Scheduling does not end the current Turn; continue all useful work that can be completed before waiting.", "schedule.set", typebox_exports.Object({ at: typebox_exports.String(), reason: typebox_exports.String() }))],
     ["team.list", tool("team_list", "Read the ledger-derived team roster and liveness state.", "team.list", typebox_exports.Object({}))],
     ["goal.get", tool("get_goal", "Read the active Goal visible to this Turn. Visibility does not establish a Goal commitment.", "goal.get", typebox_exports.Object({}))],
     ["goal.create", tool("create_goal", "Create a Root Goal from durable Human intent and bind this Turn. Do not use for greetings, questions, or routine single-turn work.", "goal.create", typebox_exports.Object({ objective: typebox_exports.String(), id: typebox_exports.Optional(typebox_exports.String()) }))],

package/dist/runner-pi.d.ts

@@ -87,6 +87,7 @@ type HandoffValidationResult = {
     token: string;
     goalId: string;
     goalRevision: number;
+    messageItemId: string;
 } | {
     accepted: false;
     fatal: boolean;
@@ -181,9 +182,6 @@ interface TurnContext {
     activeGoal: GoalSnapshot | null;
     goalCommitment: GoalCommitment | null;
 }
-interface AssistantResponse {
-    content: string;
-}
 interface RunRequest {
     agent: string;
     execution: TurnSnapshot;
@@ -197,7 +195,7 @@ interface RunRequest {
 }
 type RunnerCandidateResult = {
     outcome: "completed";
-    response: AssistantResponse;
+    finalMessageId: string;
     handoff?: TurnOutput;
 } | {
     outcome: "abnormal";
@@ -267,14 +265,17 @@ interface EnvSpecSource {
  */
 declare function resolveEnvSpec(spec: Record<string, string> | undefined, source: EnvSpecSource | undefined): Record<string, string>;
 
+interface PiAssistantResponse {
+    content: string;
+}
 interface PiStep {
     trace?: Array<{
         type: string;
         data: JsonValue;
     }>;
-    response?: AssistantResponse;
+    response?: PiAssistantResponse;
     handoff?: {
-        response: AssistantResponse;
+        response: PiAssistantResponse;
         handoff: AgentHandoff;
     };
     stopped?: boolean;
@@ -339,4 +340,4 @@ type WorkerRun = (request: WorkerRequest, emit: (event: {
 declare function runProcessWorker(run: WorkerRun): Promise<void>;
 
 export { LOCAL_PROVIDERS, PiRunnerAdapter, ProcessRunner, createPiProcessRunner, defaultAuthFile, modelCatalog, piConfig, piEnvironment, piRunnerConfigurator, piWorkerPath, providerCatalog, resolveEnvSpec, runProcessWorker, verificationWorkerPath };
-export type { ModelSummary, PiDriver, PiRunnerConfig, PiRunnerSession, PiStep, ProcessRunnerOptions, ProviderSummary, WorkerControls, WorkerRpc, WorkerRun };
+export type { ModelSummary, PiAssistantResponse, PiDriver, PiRunnerConfig, PiRunnerSession, PiStep, ProcessRunnerOptions, ProviderSummary, WorkerControls, WorkerRpc, WorkerRun };

package/dist/runner-pi.js

@@ -11,7 +11,7 @@ import {
   resolveEnvSpec,
   runProcessWorker,
   verificationWorkerPath
-} from "./chunk-7E7V6OIU.js";
+} from "./chunk-EK6BTCFG.js";
 import {
   LOCAL_PROVIDERS,
   defaultAuthFile,

package/dist/{runner-registry-GD4BYCQC.js → runner-registry-3WSOMXRW.js}

@@ -3,8 +3,8 @@ const require = __goahCreateRequire(import.meta.url);
 import {
   runnerManifests,
   runnerPlugin
-} from "./chunk-D2DVAH37.js";
-import "./chunk-7E7V6OIU.js";
+} from "./chunk-R6GKCNTB.js";
+import "./chunk-EK6BTCFG.js";
 import "./chunk-6M3OOCKO.js";
 import "./chunk-K26BVR6O.js";
 import "./chunk-IIJQ3DW4.js";

package/dist/sqlite.d.ts

@@ -320,7 +320,8 @@ interface Ledger extends EventStore {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mail: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];
@@ -408,7 +409,8 @@ declare class SqliteLedger implements Ledger {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mails: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];

package/dist/sqlite.js

@@ -3,7 +3,7 @@ const require = __goahCreateRequire(import.meta.url);
 import {
   SQLITE_SCHEMA_VERSION,
   SqliteLedger
-} from "./chunk-YH6YJ2IB.js";
+} from "./chunk-CDELLMIJ.js";
 import "./chunk-4KA63VNZ.js";
 import "./chunk-KAO7WIXG.js";
 import "./chunk-R6I3VKME.js";

package/dist/supervisor.d.ts

@@ -304,9 +304,6 @@ interface TurnContext {
     activeGoal: GoalSnapshot | null;
     goalCommitment: GoalCommitment | null;
 }
-interface AssistantResponse {
-    content: string;
-}
 interface RunRequest {
     agent: string;
     execution: TurnSnapshot;
@@ -320,7 +317,7 @@ interface RunRequest {
 }
 type RunnerCandidateResult = {
     outcome: "completed";
-    response: AssistantResponse;
+    finalMessageId: string;
     handoff?: TurnOutput;
 } | {
     outcome: "abnormal";
@@ -398,7 +395,8 @@ interface Ledger extends EventStore {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mail: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];

package/dist/supervisor.js

@@ -15,7 +15,7 @@ import {
   renderDashboard,
   runSupervisorDaemon,
   selectRecoveryEvents
-} from "./chunk-QBD6EJ2Z.js";
+} from "./chunk-SQJZ5OFH.js";
 import "./chunk-4KA63VNZ.js";
 import "./chunk-KAO7WIXG.js";
 import "./chunk-R6I3VKME.js";

package/dist/testkit.d.ts

@@ -269,6 +269,7 @@ type HandoffValidationResult = {
     token: string;
     goalId: string;
     goalRevision: number;
+    messageItemId: string;
 } | {
     accepted: false;
     fatal: boolean;
@@ -296,9 +297,6 @@ interface TurnContext {
     activeGoal: GoalSnapshot | null;
     goalCommitment: GoalCommitment | null;
 }
-interface AssistantResponse {
-    content: string;
-}
 interface RunRequest {
     agent: string;
     execution: TurnSnapshot;
@@ -370,7 +368,8 @@ interface Ledger extends EventStore {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mail: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];
@@ -457,7 +456,8 @@ declare class SqliteLedger implements Ledger {
     renewTurnLease(id: string, leaseToken: string, leaseUntil: string, now: string): TurnSnapshot;
     appendTurnEvent(input: EventInput, leaseToken: string): EventRecord;
     repairTurnAttempt(id: string, reason: string, now: string, actor: string): TurnItemSnapshot[];
-    finishTurn(id: string, status: "completed" | "failed" | "interrupted", error: JsonValue | null, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
+    finishTurn(id: string, status: "failed" | "interrupted", error: JsonValue, now: string, actor: string): TurnSnapshot;
+    commitTurnResponse(id: string, responseItemId: string, now: string, actor: string, mailIds?: string[]): TurnSnapshot;
     releaseTurnProcess(id: string, actor: string): TurnSnapshot;
     putMail(mail: MailSnapshot, actor: string, wakeId?: string): EventRecord;
     putMails(mails: MailSnapshot[], actor: string, wakeId?: string): EventRecord[];
@@ -491,14 +491,17 @@ declare class SqliteLedger implements Ledger {
     rebuildProjections(): void;
 }
 
+interface PiAssistantResponse {
+    content: string;
+}
 interface PiStep {
     trace?: Array<{
         type: string;
         data: JsonValue;
     }>;
-    response?: AssistantResponse;
+    response?: PiAssistantResponse;
     handoff?: {
-        response: AssistantResponse;
+        response: PiAssistantResponse;
         handoff: AgentHandoff;
     };
     stopped?: boolean;

package/dist/testkit.js

@@ -2,7 +2,7 @@ import { createRequire as __goahCreateRequire } from "node:module";
 const require = __goahCreateRequire(import.meta.url);
 import {
   SqliteLedger
-} from "./chunk-YH6YJ2IB.js";
+} from "./chunk-CDELLMIJ.js";
 import "./chunk-4KA63VNZ.js";
 import "./chunk-KAO7WIXG.js";
 import "./chunk-R6I3VKME.js";
@@ -107,6 +107,10 @@ function assertLedgerConformance(create) {
     throw new Error("ledger conformance: consumed Wake did not link its Turn");
   if (ledger.wakeTriggers("z").some((trigger) => trigger.status !== "resolved"))
     throw new Error("ledger conformance: consumed Wake retained pending triggers");
+  ledger.putTurnItem({ id: "turn:a:answer", turnId: turn.id, ordinal: 1, type: "assistant_message", status: "completed", data: { text: "verified" }, createdAt: clock.now().toISOString(), completedAt: clock.now().toISOString() }, "a");
+  ledger.commitTurnResponse(turn.id, "turn:a:answer", clock.now().toISOString(), "supervisor");
+  if (ledger.turn(turn.id)?.status !== "completed" || !ledger.readStream(`turn:${turn.id}`).some((item) => item.type === "response.committed" && item.data.messageItemId === "turn:a:answer"))
+    throw new Error("ledger conformance: canonical Assistant response was not committed");
   if (first.event.ts !== clock.now().toISOString())
     throw new Error("ledger conformance: injected clock was ignored");
   const informational = ledger.appendEvent({ streamId: "conformance:events", ts: clock.now().toISOString(), actor: "a", type: "transcript.conformance_info", data: {}, ignorable: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goah/cli",
-  "version": "0.13.3",
+  "version": "0.13.4",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",