sortie-dogs 0.9.11 → 0.9.12

package/README.md

@@ -22,7 +22,7 @@ Requirements: Node.js 22.6 or newer, npm, and OpenCode.
 
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [テスト実行](docs/testing.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.9.11](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.11)
+Release: [v0.9.12](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.12)
 
 ## Provisional quality–cost position
 
@@ -74,6 +74,15 @@ models are reserved for implementation, escalation, and independent review.
 Writes stay scoped, and completion requires validation evidence. Every completed
 run can return a concise Speed / Cost / Proof debrief.
 
+### Use only as much harness as the task needs
+
+Small changes can skip Scout and independent review when one worker and targeted
+validation are sufficient. Larger work can be decomposed into multiple units;
+units that are safely independent can use a Luna fabric DAG for bounded parallel
+execution. Higher-risk candidates add independent review, while full-suite and
+package verification are reserved for release work. Not every task pays the
+cost of the heaviest workflow.
+
 ## Designed to coexist with OpenCode
 
 Sortie-dogs adds a workflow to your existing setup rather than replacing it.
@@ -299,6 +308,18 @@ dog-coordinator: completion evidence accepted
    progress; repeated batches remain bounded rather than becoming endless
    delegation.
 
+## Built to work on itself
+
+Self-improvement keeps the same scoped manifests, worker ownership, validation,
+and review gates as other work. A loaded plugin is not treated as hot-reloadable:
+source changes are validated first, then packaged into an isolated `_testenv`
+fixture and exercised through the real OpenCode CLI. Continuation and compaction
+changes must demonstrate same-session recovery and terminal completion there.
+
+`npm run test:full` is reserved for explicit release validation; ordinary
+changes run targeted tests and `npm test`. The control plane coordinating a run
+is not replaced while that run is in flight.
+
 ## A visual walkthrough
 
 ### Control complexity

package/dist/plugin/continuation.d.ts

@@ -199,7 +199,7 @@ export interface ContinuationHooks {
     toolStarted(sessionID: string, tool: string): void;
     blocksTool(sessionID: string): boolean;
     sessionIdle(sessionID: string): Promise<void>;
-    stopAutomaticRecovery(sessionID: string, abortSession?: boolean): Promise<void>;
+    stopAutomaticRecovery(sessionID: string, abortSession?: boolean, resumeOnRealUserTurn?: boolean): Promise<void>;
     recoverStalledTask(sessionID: string, callIDs: readonly string[]): Promise<"recovered" | "identity-rejected" | "capability-unavailable" | "request-rejected">;
     forgetSession(sessionID: string): void;
 }

package/dist/plugin/continuation.js

@@ -225,6 +225,7 @@ export function createContinuationHooks(client, directory, policySource, timings
     const sessions = new Map();
     const warned = new Set();
     const stoppedSessions = new Set();
+    const realTurnResumableStops = new Set();
     function observeTransition(type, sessionID, state, reason) {
         try {
             transitionObserver?.({
@@ -811,8 +812,9 @@ export function createContinuationHooks(client, directory, policySource, timings
         }
         sessions.delete(sessionID);
         stoppedSessions.delete(sessionID);
+        realTurnResumableStops.delete(sessionID);
     }
-    async function stopAutomaticRecovery(sessionID, abortSession = true) {
+    async function stopAutomaticRecovery(sessionID, abortSession = true, resumeOnRealUserTurn = false) {
         const state = sessions.get(sessionID);
         if (state !== undefined) {
             clearTimer(state.cooldownTimer);
@@ -830,8 +832,14 @@ export function createContinuationHooks(client, directory, policySource, timings
         }
         stoppedSessions.delete(sessionID);
         stoppedSessions.add(sessionID);
+        if (resumeOnRealUserTurn)
+            realTurnResumableStops.add(sessionID);
+        else
+            realTurnResumableStops.delete(sessionID);
         while (stoppedSessions.size > MAX_TRACKED_SESSIONS) {
-            stoppedSessions.delete(stoppedSessions.values().next().value);
+            const oldest = stoppedSessions.values().next().value;
+            stoppedSessions.delete(oldest);
+            realTurnResumableStops.delete(oldest);
         }
         const abort = abortSession ? client?.session?.abort : undefined;
         if (abort !== undefined) {
@@ -842,6 +850,8 @@ export function createContinuationHooks(client, directory, policySource, timings
         }
     }
     async function recoverStalledTask(sessionID, callIDs) {
+        if (stoppedSessions.has(sessionID))
+            return "request-rejected";
         const active = policy();
         const resolution = resolveContinuation({
             identity: await readIdentity(sessionID),
@@ -863,6 +873,8 @@ export function createContinuationHooks(client, directory, policySource, timings
             // Reserve durable authority before mutating the host session. A configured authority that
             // cannot issue a ticket must not cause an abort/retry loop or an unproven synthetic send.
             const metadata = await ticketMetadata(sessionID, `watchdog:${callIDs.join(",")}`);
+            if (stoppedSessions.has(sessionID))
+                return "request-rejected";
             await abort.call(client.session, {
                 path: { id: sessionID },
                 query: { directory },
@@ -1164,8 +1176,11 @@ export function createContinuationHooks(client, directory, policySource, timings
                 output.enabled = false;
         },
         observeModel(sessionID, model, synthetic = false) {
-            if (stoppedSessions.has(sessionID))
-                return;
+            if (stoppedSessions.has(sessionID)) {
+                if (synthetic || !realTurnResumableStops.delete(sessionID))
+                    return;
+                stoppedSessions.delete(sessionID);
+            }
             if (!nonEmpty(model.providerID) || !nonEmpty(model.modelID))
                 return;
             const state = stateFor(sessionID);

package/dist/plugin/index.d.ts

@@ -91,6 +91,11 @@ export type HandoffDenialReason = "configuration-unavailable" | "path-invalid" |
 export type FreshSessionReason = "child-lineage" | "asset-contract-skew";
 export type FreshSessionAction = "open-fresh-root" | "install-assets-then-open-fresh-root" | "restart-host-after-install";
 export type FreshSessionResult = Readonly<{
+    status: "redispatch-queued";
+    reason: FreshSessionReason;
+    source_session_id: string;
+    retry_same_session: false;
+}> | Readonly<{
     status: "redispatched";
     reason: FreshSessionReason;
     source_session_id: string;

package/dist/plugin/index.js

@@ -483,15 +483,58 @@ function sameRelativePath(left, right) {
 function textPart(part) {
     return isRecord(part) && typeof part.text === "string" ? part.text : undefined;
 }
+const FILE_PART_KEYS = new Set(["id", "sessionID", "messageID", "type", "mime", "filename", "url", "source"]);
+function safeFilePart(part) {
+    if (Object.keys(part).some((key) => !FILE_PART_KEYS.has(key)) ||
+        typeof part.mime !== "string" || part.mime.length === 0 ||
+        typeof part.url !== "string" || part.url.length === 0 ||
+        (part.filename !== undefined && typeof part.filename !== "string") ||
+        (part.id !== undefined && typeof part.id !== "string") ||
+        (part.sessionID !== undefined && typeof part.sessionID !== "string") ||
+        (part.messageID !== undefined && typeof part.messageID !== "string") ||
+        (part.source !== undefined && !isRecord(part.source)))
+        return undefined;
+    return {
+        type: "file",
+        mime: part.mime,
+        ...(part.filename === undefined ? {} : { filename: part.filename }),
+        url: part.url,
+    };
+}
+/** OpenCode expands text attachments into synthetic explanatory text alongside the real file.
+ * Those derived text parts carry no user authority and are never copied into a fresh prompt.
+ * A ticket-bearing synthetic turn (or a turn without real user text and a safe file) stays synthetic.
+ */
+function realAttachmentParts(parts) {
+    const hasUserText = parts.some((part) => isRecord(part) && part.type === "text" &&
+        part.synthetic !== true && typeof part.text === "string" && part.text.trim().length > 0);
+    const hasFile = parts.some((part) => isRecord(part) && part.type === "file" && part.synthetic !== true && safeFilePart(part) !== undefined);
+    if (!hasUserText || !hasFile || parts.some((part) => isRecord(part) && part.synthetic === true &&
+        (part.type !== "text" || typeof part.text !== "string" || part.metadata !== undefined)))
+        return parts;
+    return parts.filter((part) => !isRecord(part) || part.synthetic !== true);
+}
+function syntheticPrompt(parts) {
+    return realAttachmentParts(parts).some((part) => isRecord(part) && part.synthetic === true);
+}
 function freshSessionPrompt(parts) {
     const prompt = [];
-    for (const part of parts) {
-        if (!isRecord(part) || part.type !== "text" || part.synthetic === true || typeof part.text !== "string") {
+    for (const part of realAttachmentParts(parts)) {
+        if (!isRecord(part) || part.synthetic === true)
             return undefined;
+        if (part.type === "text" && typeof part.text === "string")
+            prompt.push({ type: "text", text: part.text });
+        else if (part.type === "file") {
+            const attachment = safeFilePart(part);
+            if (attachment === undefined)
+                return undefined;
+            prompt.push(attachment);
         }
-        prompt.push({ type: "text", text: part.text });
+        else
+            return undefined;
     }
-    return prompt.length > 0 && prompt.some(({ text }) => text.trim().length > 0) ? prompt : undefined;
+    return prompt.length > 0 && prompt.some((part) => part.type === "text" && part.text.trim().length > 0)
+        ? prompt : undefined;
 }
 /**
  * One handoff entry per line. The coordinator asset emits inline digests as `key: value`, often
@@ -1282,10 +1325,6 @@ export const SortieDogsPlugin = async (input, options) => {
         const messages = input.client?.session?.messages;
         if (messages === undefined)
             return undefined;
-        const currentText = currentParts.filter(isRecord).filter((part) => part.type === "text" && part.synthetic !== true)
-            .map((part) => part.text).filter((text) => typeof text === "string");
-        if (currentText.length === 0)
-            return undefined;
         for (const delay of [0, 10, 50]) {
             if (delay > 0)
                 await new Promise((resolve) => setTimeout(resolve, delay));
@@ -1303,11 +1342,10 @@ export const SortieDogsPlugin = async (input, options) => {
                     continue;
                 const info = isRecord(message.info) ? message.info : undefined;
                 if ((info?.role ?? message.role) !== "user" || (info?.agent ?? message.agent) !== selectedAgent ||
-                    !Array.isArray(message.parts) || message.parts.some((part) => isRecord(part) && part.synthetic === true))
+                    !Array.isArray(message.parts) || syntheticPrompt(message.parts))
                     continue;
-                const persistedText = message.parts.filter(isRecord).filter((part) => part.type === "text")
-                    .map((part) => part.text).filter((text) => typeof text === "string");
-                if (JSON.stringify(persistedText) !== JSON.stringify(currentText))
+                const persistedParts = freshSessionPrompt(message.parts);
+                if (persistedParts === undefined || JSON.stringify(persistedParts) !== JSON.stringify(currentParts))
                     continue;
                 const messageID = info?.id ?? message.id;
                 if (typeof messageID === "string" && messageID.length > 0)
@@ -1503,16 +1541,24 @@ export const SortieDogsPlugin = async (input, options) => {
         }
     }
     async function acceptRealGoalTurn(sessionID, messageID, selectedAgent, parts) {
+        // Root recovery can prove the persisted user message identity before its parts are available.
+        // Preserve that existing empty projection while every observed non-empty shape stays strict.
+        const safeParts = parts.length === 0
+            ? []
+            : freshSessionPrompt(parts);
+        if (safeParts === undefined)
+            throw new Error("SORTIE_GOAL_CONTROL_DENIED: unsafe-message-parts");
         await recoverCompletedGoalReservations(sessionID);
         const ledger = await goalLedger(sessionID);
         const state = (await ledger.readGoal()).state;
         if (state.latest_user_message_id === messageID)
             return;
         const at = new Date().toISOString();
-        const explicitContinuation = parts.map(textPart).filter((value) => value !== undefined).join("\n")
+        const explicitContinuation = safeParts.filter((part) => part.type === "text")
+            .map((part) => part.text).join("\n")
             .split(/\r?\n/u).some((line) => /^\s*(?:goal_acceptance_fingerprint|goal_budget_(?:units|time_ms|cost_usd))\s*:/iu.test(line));
         if (state.goal_id === null || state.phase === "terminal" || (state.phase === "stopped" && !explicitContinuation)) {
-            const acceptance = goalFingerprint({ message_id: messageID, parts: parts.map(textPart).filter((value) => value !== undefined) });
+            const acceptance = goalFingerprint({ message_id: messageID, parts: safeParts.map((part) => part.type === "text" ? part.text : part) });
             await ledger.appendGoal({ kind: "goal.accepted", at,
                 goal_id: goalFingerprint({ root: goalRoot(sessionID), origin_user_message_id: messageID }),
                 revision: 1, scope_epoch: 1, acceptance_fingerprint: acceptance,
@@ -1544,7 +1590,7 @@ export const SortieDogsPlugin = async (input, options) => {
         const persistedInfo = isRecord(message.info) ? message.info : undefined;
         if ((persistedInfo?.role ?? message.role) !== "user" ||
             (persistedInfo?.agent ?? message.agent) !== COORDINATOR_AGENT || !Array.isArray(message.parts) ||
-            message.parts.some((part) => isRecord(part) && part.synthetic === true))
+            syntheticPrompt(message.parts))
             return;
         await acceptRealGoalTurn(sessionID, info.id, COORDINATOR_AGENT, message.parts);
         goalDeclarationAuthority.set(sessionID, info.id);
@@ -1685,9 +1731,6 @@ export const SortieDogsPlugin = async (input, options) => {
         else if (receipt === undefined && proved) {
             receipt = await terminalGoal(sessionID, "completed", "succeeded").catch(() => undefined);
         }
-        else if (receipt === undefined && outcome === "DONE") {
-            receipt = await terminalGoal(sessionID, "completed", "succeeded").catch(() => undefined);
-        }
         else if (receipt === undefined && outcome === "INTERRUPTED") {
             receipt = await terminalGoal(sessionID, "stopped", "stopped").catch(() => undefined);
         }
@@ -2184,57 +2227,67 @@ export const SortieDogsPlugin = async (input, options) => {
         }
         const key = `${sourceSessionID}\u0000${reason}`;
         const existing = freshSessionRedispatches.get(key);
+        const queued = { status: "redispatch-queued", reason,
+            source_session_id: sourceSessionID, retry_same_session: false };
         if (existing !== undefined)
-            return await existing.operation;
-        const operation = (async () => {
-            let targetSessionID;
-            try {
-                const created = await create.call(input.client.session, {
-                    query: { directory: input.worktree ?? input.directory },
-                    body: {},
-                });
-                const payload = isRecord(created) && "data" in created ? created.data : created;
-                if (!isRecord(payload) || typeof payload.id !== "string" || payload.id.length === 0) {
-                    return freshSessionFallback(reason, fallbackAction);
-                }
-                targetSessionID = payload.id;
-                const parentID = typeof payload.parentID === "string" ? payload.parentID
-                    : typeof payload.parentId === "string" ? payload.parentId
-                        : undefined;
-                if (parentID !== undefined) {
-                    await deleteFreshSession(targetSessionID);
-                    return freshSessionFallback(reason, fallbackAction);
-                }
-                goalRootSessions.set(targetSessionID, goalRoot(sourceSessionID));
-                const ticket = await issueGoalTicket(targetSessionID, `fresh-root:${reason}`);
-                if (!ticket.issued)
-                    throw new Error("fresh coordinator ticket already outstanding");
-                const sent = await send.call(input.client.session, {
-                    path: { id: targetSessionID },
-                    query: { directory: input.worktree ?? input.directory },
-                    body: { agent: COORDINATOR_AGENT, parts: prompt.map((part) => ({ ...part, synthetic: true,
-                            metadata: ticket.metadata })) },
-                });
-                if (!promptAccepted(sent))
-                    throw new Error("fresh coordinator prompt rejected");
-                appLogInfo("fresh-session.redispatched", sourceSessionID, {
-                    reason,
-                    targetSessionID: targetSessionID.slice(0, 128),
-                });
-                return {
-                    status: "redispatched",
-                    reason,
-                    source_session_id: sourceSessionID,
-                    target_session_id: targetSessionID,
-                    retry_same_session: false,
-                };
-            }
-            catch {
-                if (targetSessionID !== undefined)
-                    await deleteFreshSession(targetSessionID);
-                return freshSessionFallback(reason, fallbackAction);
-            }
-        })();
+            return existing.settled ? await existing.operation : queued;
+        // Both session.create and promptAsync enter the host request scheduler. Defer the entire
+        // redispatch until the child chat hook has returned its typed control error.
+        const operation = new Promise((accept) => {
+            setTimeout(() => {
+                void (async () => {
+                    let targetSessionID;
+                    try {
+                        const created = await create.call(input.client.session, {
+                            query: { directory: input.worktree ?? input.directory },
+                            body: {},
+                        });
+                        const payload = isRecord(created) && "data" in created ? created.data : created;
+                        if (!isRecord(payload) || typeof payload.id !== "string" || payload.id.length === 0) {
+                            return freshSessionFallback(reason, fallbackAction);
+                        }
+                        targetSessionID = payload.id;
+                        const parentID = typeof payload.parentID === "string" ? payload.parentID
+                            : typeof payload.parentId === "string" ? payload.parentId
+                                : undefined;
+                        if (parentID !== undefined) {
+                            await deleteFreshSession(targetSessionID);
+                            return freshSessionFallback(reason, fallbackAction);
+                        }
+                        goalRootSessions.set(targetSessionID, goalRoot(sourceSessionID));
+                        const ticket = await issueGoalTicket(targetSessionID, `fresh-root:${reason}`);
+                        if (!ticket.issued)
+                            throw new Error("fresh coordinator ticket already outstanding");
+                        const sendFresh = send;
+                        const sent = await sendFresh.call(input.client.session, {
+                            path: { id: targetSessionID },
+                            query: { directory: input.worktree ?? input.directory },
+                            body: { agent: COORDINATOR_AGENT, parts: prompt.map((part) => part.type === "text"
+                                    ? { ...part, synthetic: true, metadata: ticket.metadata }
+                                    : part) },
+                        });
+                        if (!promptAccepted(sent))
+                            throw new Error("fresh coordinator prompt rejected");
+                        appLogInfo("fresh-session.redispatched", sourceSessionID, {
+                            reason,
+                            targetSessionID: targetSessionID.slice(0, 128),
+                        });
+                        return {
+                            status: "redispatched",
+                            reason,
+                            source_session_id: sourceSessionID,
+                            target_session_id: targetSessionID,
+                            retry_same_session: false,
+                        };
+                    }
+                    catch {
+                        if (targetSessionID !== undefined)
+                            await deleteFreshSession(targetSessionID);
+                        return freshSessionFallback(reason, fallbackAction);
+                    }
+                })().then(accept);
+            }, 0);
+        });
         const entry = { operation, settled: false };
         freshSessionRedispatches.set(key, entry);
         void operation.then((result) => {
@@ -2257,7 +2310,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 break;
             freshSessionRedispatches.delete(completed[0]);
         }
-        return await operation;
+        return queued;
     }
     async function ensureLoaded() {
         if (loaded?.gate !== undefined)
@@ -3428,9 +3481,6 @@ export const SortieDogsPlugin = async (input, options) => {
                     contract_fingerprint: structuralAdmission.contract_fingerprint, experience: experience.trace });
             }
             const coordinator = await getParallelCoordinator();
-            if (await coordinator.targetCheckedOut(`refs/heads/${structuralAdmission.contract.provenance.target_branch}`)) {
-                return JSON.stringify({ status: "sol-serial", reason: "target-checked-out", experience: experience.trace });
-            }
             const result = await coordinator.prepareFabric(contract, ownerRoot, executionPlanPath === undefined ? undefined : await readJson(resolve(executionPlanPath), INPUT_LIMITS.parallel));
             if (result.status === "sol-serial")
                 return JSON.stringify({ ...result, experience: experience.trace });
@@ -5020,15 +5070,19 @@ export const SortieDogsPlugin = async (input, options) => {
                 const agent = info?.agent ?? message.agent;
                 if (typeof agent !== "string")
                     return undefined;
-                if (message.parts !== undefined && !Array.isArray(message.parts))
+                const parts = message.parts === undefined ? [] : message.parts;
+                if (!Array.isArray(parts))
                     return undefined;
-                const synthetic = Array.isArray(message.parts) && message.parts.some((part) => isRecord(part) && part.synthetic === true);
+                const synthetic = syntheticPrompt(parts);
                 if (synthetic)
                     continue;
+                const persistedParts = parts.length === 0 ? [] : freshSessionPrompt(parts);
+                if (persistedParts === undefined)
+                    return undefined;
                 const messageID = info?.id ?? message.id;
                 if (typeof messageID !== "string" || messageID.length === 0)
                     return undefined;
-                persistedTurn = { agent, synthetic: false, messageID };
+                persistedTurn = { agent, synthetic: false, messageID, parts: persistedParts };
                 break;
             }
             return { hasForeignUserTurn: persistedTurn?.agent !== undefined && persistedTurn.agent !== COORDINATOR_AGENT,
@@ -5124,7 +5178,7 @@ export const SortieDogsPlugin = async (input, options) => {
             return false;
         await rememberCoordinatorRoot(sessionID);
         if (persistedTurn !== undefined) {
-            await acceptRealGoalTurn(sessionID, persistedTurn.messageID, persistedTurn.agent, []);
+            await acceptRealGoalTurn(sessionID, persistedTurn.messageID, persistedTurn.agent, persistedTurn.parts);
             goalDeclarationAuthority.set(sessionID, persistedTurn.messageID);
         }
         await pinAssetVersion(sessionID);
@@ -5563,16 +5617,23 @@ export const SortieDogsPlugin = async (input, options) => {
                     .replaceAll(CONTINUATION_MARKER, "")
                     .trimEnd();
             }
+            const hostRunOutcome = terminalRunOutcome(textOutput.text);
             textOutput.text = await preserveActiveGoalContinuation(textInput.sessionID, textOutput.text, textInput.messageID);
-            const runOutcome = terminalRunOutcome(textOutput.text);
+            // Preserve a host DONE claim for proof checks while allowing an ordinary local INTERRUPTED
+            // response to remain presentation-only IN_PROGRESS continuation.
+            const runOutcome = hostRunOutcome === "DONE" ? hostRunOutcome : terminalRunOutcome(textOutput.text);
             const terminal = runOutcome === undefined || !isCoordinatorSession(textInput.sessionID)
                 ? undefined
                 : await terminalGoalFromHostText(textInput.sessionID, textOutput.text);
-            if (runOutcome === "DONE" && terminal !== undefined && (terminal.delivery === "running" ||
-                (terminal.receipt === undefined && terminal.goal !== undefined && terminal.goal.goal_id !== null))) {
-                textOutput.text = replaceDoneTerminalStatus(textOutput.text, terminal.delivery === "running"
-                    ? "status: IN_PROGRESS — durable delivery active; same sessionでjoinまたはstale reconcileが必要"
-                    : "status: IN_PROGRESS\ngoal_control: accepted criteria remain unproved");
+            if (runOutcome === "DONE" && terminal?.delivery === "running") {
+                textOutput.text = replaceDoneTerminalStatus(textOutput.text, "status: IN_PROGRESS — durable delivery active; same sessionでjoinまたはstale reconcileが必要");
+                await continuation.stopAutomaticRecovery(textInput.sessionID, false, true);
+            }
+            else if (runOutcome === "DONE" && terminal?.receipt === undefined &&
+                terminal?.goal !== undefined && terminal.goal.goal_id !== null) {
+                textOutput.text = replaceDoneTerminalStatus(textOutput.text, "status: INTERRUPTED — accepted criteria remain unproved\n" +
+                    "TRUE_INTERRUPTION: internal: accepted criteria remain unproved");
+                await continuation.stopAutomaticRecovery(textInput.sessionID, false, true);
             }
             if (runOutcome !== "DONE" && terminal?.delivery === "ready" && terminal.receipt?.status === "succeeded") {
                 textOutput.text = replaceTerminalStatus(textOutput.text, "status: DONE");
@@ -5666,7 +5727,7 @@ export const SortieDogsPlugin = async (input, options) => {
             observedChildTerminals.delete(chatInput.sessionID);
             await serializeChatTransition(chatInput.sessionID, async () => {
                 const parentID = chatParentID(chatInput);
-                const synthetic = output.parts.some((part) => isRecord(part) && part.synthetic === true);
+                const synthetic = syntheticPrompt(output.parts);
                 const selectedAgent = chatInput.agent ?? output.message.agent;
                 if (parentID !== undefined)
                     rememberParent(chatInput.sessionID, parentID);
@@ -5676,8 +5737,15 @@ export const SortieDogsPlugin = async (input, options) => {
                     output.message.agent = chatInput.agent;
                 }
                 const requestedCoordinator = selectedAgent === COORDINATOR_AGENT;
+                const projectedCoordinatorParts = requestedCoordinator && !synthetic && output.parts.length > 0
+                    ? freshSessionPrompt(output.parts)
+                    : undefined;
+                if (requestedCoordinator && !synthetic && output.parts.length > 0 && projectedCoordinatorParts === undefined) {
+                    throw new Error("SORTIE_GOAL_CONTROL_DENIED: unsafe-message-parts");
+                }
                 const messageID = realMessageID(chatInput, output) ?? (synthetic ? undefined
-                    : await persistedCurrentRealMessageID(chatInput.sessionID, selectedAgent, output.parts));
+                    : projectedCoordinatorParts === undefined ? undefined
+                        : await persistedCurrentRealMessageID(chatInput.sessionID, selectedAgent, projectedCoordinatorParts));
                 if (requestedCoordinator && !coordinatorRoot && (parentID !== undefined || knownChildSessions.has(chatInput.sessionID)) &&
                     !synthetic && messageID !== undefined) {
                     await acceptRealGoalTurn(chatInput.sessionID, messageID, selectedAgent, output.parts);
@@ -5724,11 +5792,11 @@ export const SortieDogsPlugin = async (input, options) => {
                         // Some native hosts persist the user message only after this hook returns. Defer to the
                         // system-transform boundary, but retain no synthetic authority and accept only the exact
                         // final persisted real-user parts through persistedCurrentRealMessageID.
-                        pendingRealGoalTurns.set(chatInput.sessionID, { selectedAgent, parts: [...output.parts] });
+                        pendingRealGoalTurns.set(chatInput.sessionID, { selectedAgent, parts: projectedCoordinatorParts ?? [] });
                         pruneParallelChildMap(pendingRealGoalTurns);
                         schedulePendingRealGoalRecovery(chatInput.sessionID);
                     }
-                    const prompt = synthetic ? undefined : freshSessionPrompt(output.parts);
+                    const prompt = projectedCoordinatorParts;
                     if (prompt !== undefined)
                         coordinatorPrompts.set(chatInput.sessionID, prompt);
                     // Synthetic coordinator turns reach here only after consumeGoalTicket accepted the
@@ -6679,14 +6747,19 @@ export const SortieDogsPlugin = async (input, options) => {
                 return;
             // Deletion is terminal for watchdog recovery. Disarm synchronously before any generic event
             // processing can await, touch activity, or let a queued sweep recover the cancelled root.
-            if (event.type === "session.deleted")
+            if (event.type === "session.deleted") {
                 disarmDeletedCoordinatorTaskWatchdog(eventSessionID);
+                await continuation.stopAutomaticRecovery(eventSessionID, false);
+            }
             if (event.type === "message.updated" && info !== undefined) {
                 rememberCoordinatorInterruption(eventSessionID, info);
-                await acceptPersistedRealGoalEvent(eventSessionID, info);
+                if (pendingRealGoalTurns.has(eventSessionID))
+                    await recoverPendingRealGoalTurn(eventSessionID);
+                else
+                    await acceptPersistedRealGoalEvent(eventSessionID, info);
             }
             if (pendingRealGoalTurns.has(eventSessionID) &&
-                (event.type === "message.updated" || event.type === "message.part.updated")) {
+                event.type === "message.part.updated") {
                 await recoverPendingRealGoalTurn(eventSessionID);
             }
             const eventPartTime = isRecord(eventPart?.time) ? eventPart.time : undefined;

package/dist/plugin/run-metrics.d.ts

@@ -112,7 +112,15 @@ type SortieGoalSnapshot = Pick<GoalFlightState, "acceptance_contract" | "consume
 export declare function createSortieResult(receipt: GoalTerminalReceipt, goal: SortieGoalSnapshot, metrics: RunMetrics | undefined, asOf?: string, records?: readonly GoalFlightEventRecord[]): SortieResult;
 export type RunTerminalOutcome = "DONE" | "INTERRUPTED" | "BLOCKED" | "NEED_DECISION";
 export declare function collectRunMetrics(client: RunMetricsClient | undefined, rootSessionID: string, directory?: string, now?: number, window?: RunMetricsWindow): Promise<RunMetrics | undefined>;
-export declare function formatSortieResult(result: SortieResult): string;
+export interface SortieResultPresentation {
+    readonly implementation?: string;
+    readonly pending?: string;
+    readonly next?: string;
+    readonly commit?: string;
+    readonly statusSummary?: string;
+    readonly stopReason?: string;
+}
+export declare function formatSortieResult(result: SortieResult, presentation?: SortieResultPresentation): string;
 export declare function formatRunMetrics(metrics: RunMetrics): string;
 export declare function isDoneTerminalText(text: string): boolean;
 export declare function terminalRunOutcome(text: string): RunTerminalOutcome | undefined;

package/dist/plugin/run-metrics.js

@@ -1,4 +1,4 @@
-import { buildDebrief, renderDebrief, observeDebriefSession } from "./sortie-debrief.js";
+import { buildDebrief, renderDebrief, renderDebriefProof, observeDebriefSession } from "./sortie-debrief.js";
 import { goalFingerprint } from "../core/goal-bound.js";
 import { renderCareer } from "./sortie-career.js";
 const unavailable = (reason) => ({ availability: "unavailable", value: null, reason });
@@ -341,25 +341,61 @@ function duration(milliseconds) {
 function metricText(metric, render) {
     return metric.availability === "available" ? render(metric.value) : "計測不可";
 }
-export function formatSortieResult(result) {
+const displayText = (value) => value?.replace(/[\r\n\t]+/gu, " ").trim() || "未取得";
+const reportFence = (body) => {
+    const longest = Math.max(0, ...[...body.matchAll(/^~+/gmu)].map((match) => match[0].length));
+    const fence = "~".repeat(Math.max(3, longest + 1));
+    return `${fence}text\n${body}\n${fence}`;
+};
+export function formatSortieResult(result, presentation = {}) {
     const criteria = metricText(result.proof.criteria, (entries) => {
         const passing = entries.filter(({ status }) => status === "PASS").length;
         return `${passing}/${entries.length}`;
     });
-    const achievement = result.mission.status === "COMPLETED" ? "完了"
+    const achievement = result.mission.status === "COMPLETED" ? "COMPLETED"
+        : result.mission.status === "INTERRUPTED" ? "INTERRUPTED"
+            : result.mission.status === "EXTERNAL_BLOCKER" ? "EXTERNAL_BLOCKER" : "USER_DECISION";
+    const summaryLabel = result.mission.status === "COMPLETED" ? "完了"
         : result.mission.status === "INTERRUPTED" ? "中断（未完了）"
-            : result.mission.status === "EXTERNAL_BLOCKER" ? "外部要因で未完了"
-                : "ユーザー判断待ち（未完了）";
+            : result.mission.status === "EXTERNAL_BLOCKER" ? "外部要因で未完了" : "ユーザー判断待ち（未完了）";
     const color = result.mission.status === "COMPLETED" ? "🟢" : result.mission.status === "EXTERNAL_BLOCKER" ? "🔴" : "🟡";
+    const proof = renderDebriefProof(result.debrief);
     const body = [
-        `**⚡ 任務経過（待機含む）:** **${metricText(result.speed.goal_wall_ms, duration)}**`,
-        `**🪙 使用量:** **${metricText(result.cost.total_tokens, (value) => `${value.toLocaleString("ja-JP")} tokens`)}** · host推定額 ${metricText(result.cost.cost_usd, (value) => `$${value.toFixed(4)}`)}（実課金換算なし）`,
+        "🐾 SORTIE DOGS — 帰還報告",
+        result.result_id[0],
+        "",
+        `${color} ${achievement} — ${displayText(presentation.statusSummary)}`,
+        "",
+        "⚔️ MISSION",
+        `経過          ⏱ ${metricText(result.speed.goal_wall_ms, duration)} ※待機含む`,
+        `最終達成条件  ◔ ${criteria}`,
+        `対象検証      ${proof.validation}`,
+        `SourceReview  ${proof.review}`,
+        `Commit        ${displayText(presentation.commit)}`,
+        "",
+        "🔧 実装",
+        displayText(presentation.implementation),
+        "",
+        "⏳ 未実施",
+        displayText(presentation.pending),
+        "",
+        "➡️ NEXT",
+        displayText(presentation.next),
+        "",
+        "🪙 COST / PACK",
+        `使用量        ${metricText(result.cost.total_tokens, (value) => `${value.toLocaleString("ja-JP")} tokens`)}`,
+        `host推定額    ${metricText(result.cost.cost_usd, (value) => `$${value.toFixed(4)}`)} ※実課金換算なし`,
+        "",
         ...renderDebrief(result.debrief),
-        `**🛡 達成:** ${color} **${achievement}** · 達成条件 **${criteria}**`,
-        "*最終応答生成前の計測*",
+        "",
         ...renderCareer(result.career),
-    ].join("\n\n");
-    return `<details>\n<summary><strong>🐾 SORTIE DOGS — 帰還報告｜${color} ${achievement}</strong></summary>\n\n${body}\n\n</details>`;
+        "",
+        "🛑 STOP REASON",
+        displayText(presentation.stopReason ?? result.mission.stop_reason),
+        "",
+        "※使用量は最終応答生成前の計測",
+    ].join("\n");
+    return `<details>\n<summary><strong>🐾 SORTIE DOGS — 帰還報告｜${color} ${summaryLabel}</strong></summary>\n\n${reportFence(body)}\n\n</details>`;
 }
 export function formatRunMetrics(metrics) {
     const elapsed = metrics.durationMilliseconds === undefined ? "duration unavailable" : `${duration(metrics.durationMilliseconds)} wall-clock`;
@@ -476,6 +512,7 @@ export function insertRunMetrics(text, metrics) {
     return lines.join(newline);
 }
 export function insertSortieResult(text, result) {
+    const presentation = extractSortiePresentation(text);
     const visible = sanitizeTerminalReport(text);
     const checkpoint = terminalCheckpoint(visible);
     if (checkpoint === undefined)
@@ -506,7 +543,7 @@ export function insertSortieResult(text, result) {
         cleaned.splice(checkpoint.index + 1, 1);
     let card;
     try {
-        card = formatSortieResult(result);
+        card = formatSortieResult(result, presentation);
     }
     catch {
         card = "<details>\n<summary><strong>🐾 SORTIE DOGS — 帰還報告</strong></summary>\n\n**確認:** 表示集計を取得できません。任務結果は先頭の状態を参照。\n\n</details>";
@@ -514,6 +551,23 @@ export function insertSortieResult(text, result) {
     cleaned.splice(checkpoint.index + 1, 0, "", card, "");
     return cleaned.join(newline).trimEnd();
 }
+function extractSortiePresentation(text) {
+    const first = topLevelLines(text).find(({ line }) => line.trim().length > 0)?.line ?? "";
+    const statusSummary = first.split(/\s+[—-]\s+/u).slice(1).join(" — ").trim() || undefined;
+    const section = (names) => {
+        const expression = new RegExp(`^[ \\t]*(?:#{1,6}[ \\t]*)?(?:\\*\\*)?(?:${names})(?:\\*\\*)?[ \\t]*:?[ \\t]*(?:\\*\\*)?[ \\t]*(.*)$`, "imu");
+        const match = expression.exec(text);
+        if (match === null)
+            return undefined;
+        if (match[1]?.trim())
+            return match[1].trim();
+        const tail = text.slice(match.index + match[0].length).split(/\r?\n/u);
+        return tail.find((line) => line.trim().length > 0 && !/^[ \\t]*(?:#{1,6}[ \\t]*)?(?:\\*\\*)?(?:変更点|実装|未実施|次|NEXT|Commit|コミット)/iu.test(line))?.trim();
+    };
+    const explicitStop = /^(?:TRUE_INTERRUPTION|TRUE_BLOCKER)[ \\t]*:[ \\t]*(.+)$/imu.exec(text)?.[1]?.trim();
+    return { statusSummary, implementation: section("変更点|実装"), pending: section("未実施"), next: section("次|NEXT"),
+        commit: section("Commit|コミット"), stopReason: explicitStop };
+}
 export function createGoalReport(result, receipt) {
     const tokens = result.cost.total_tokens.availability === "available" && Number.isSafeInteger(result.cost.total_tokens.value)
         ? result.cost.total_tokens.value : null;

package/dist/plugin/sortie-career.js

@@ -124,21 +124,25 @@ export async function collectCareer(directories, currentPath, current, read, max
 }
 export function renderCareer(career) {
     if (career === undefined)
-        return ["**📜 PACK RECORD:** 保存履歴を取得できません"];
+        return ["📜 PACK RECORD", "保存履歴を取得できません"];
     const terminal = career.goals - career.active;
-    const firstPass = career.firstPass.eligible === 0 ? "計測不可（対象0件）" : `${career.firstPass.count}/${career.firstPass.eligible}件`;
-    const minutes = (metric) => metric.covered === 0 ? "計測不可" : `${(metric.sum / 60000).toFixed(1)}分（${metric.covered}/${terminal}任務）`;
-    const models = [...career.models].sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
-    const modelText = models.slice(0, 4).map((entry) => `${entry.model.replace(/[\\`*_{}\[\]()<>!|\r\n]/gu, "").slice(0, 120)} ${entry.tokens.toLocaleString("ja-JP")}`).join(" · ");
+    const minutes = (metric) => metric.covered === 0 ? "計測不可" : `${(metric.sum / 60000).toFixed(1)}分 ※${metric.covered}/${terminal}任務`;
     return [
-        "**📜 PACK RECORD — 記録済み戦績**",
-        `**戦績:** 完了 ${career.completed} · 中断 ${career.interrupted} · 外部待機 ${career.external} · 指示待ち ${career.decision} · 進行中 ${career.active}`,
-        `**初回完遂:** ${firstPass} · 復帰 ${career.recoveries}件（計測記録 ${career.telemetryCovered}/${terminal}任務）`,
-        `**累積使用量:** ${career.tokens.covered === 0 ? "計測不可" : `${career.tokens.sum.toLocaleString("ja-JP")} tokens`}（計測 ${career.tokens.covered}/${terminal}任務）`,
-        `**累積モデル:** ${career.modelCovered === 0 ? "計測不可" : modelText || "出力なし"}${models.length > 4 ? " · ほか" : ""}（token計測 ${career.modelCovered}/${terminal}任務）`,
-        `**累積時間:** worker ${minutes(career.workerTime)} · goal期間合計 ${minutes(career.goalWall)}（待機含む・同時刻重複あり）`,
-        `**累積実行重複率:** ${career.overlap.ratio === null ? "計測不可" : `${career.overlap.ratio.toFixed(2)}×`}（総和の比・${career.overlap.covered}/${terminal}任務・速度倍率ではありません）`,
-        `**保存範囲:** ${career.since?.slice(0, 10) ?? "開始日不明"}以降の現存履歴 · ${career.coverage.included}/${career.coverage.files}ファイル${career.coverage.unavailable || career.coverage.truncated ? " · 部分集計" : ""} · 生涯戦績ではありません`,
-        ...(career.titles.length ? [`**🎖 隊の称号:** ${career.titles.join(" · ")}`] : []),
+        "📜 PACK RECORD",
+        `🏁 完了 ${career.completed}`,
+        `🟡 中断 ${career.interrupted}`,
+        `⏳ 外部待機 ${career.external}`,
+        `❓ 指示待ち ${career.decision}`,
+        `🔄 進行中 ${career.active}`,
+        `↩️ 復帰 ${career.recoveries}`,
+        "",
+        `🪙 累積使用量 ${career.tokens.covered === 0 ? "計測不可" : `${career.tokens.sum.toLocaleString("ja-JP")} tokens`} ※${career.tokens.covered}/${terminal}任務`,
+        `⏱ 累積worker ${minutes(career.workerTime)}`,
+        `🕰 累積goal ${minutes(career.goalWall)} ※待機・重複含む`,
+        `⚡ 累積重複率 ${career.overlap.ratio === null ? "計測不可" : `${career.overlap.ratio.toFixed(2)}×`} ※${career.overlap.covered}/${terminal}任務・速度倍率ではありません`,
+        "",
+        "📦 保存範囲",
+        `${career.since?.slice(0, 10) ?? "開始日不明"}以降 / ${career.coverage.included} of ${career.coverage.files} files${career.coverage.unavailable || career.coverage.truncated ? " ※部分集計" : ""}`,
+        "※生涯戦績ではありません",
     ];
 }

package/dist/plugin/sortie-debrief.d.ts

@@ -55,4 +55,8 @@ export interface Debrief {
 export declare function observeDebriefSession(id: string, root: boolean, messages: readonly Record<string, unknown>[], window?: Span): DebriefSession;
 export declare function buildDebrief(receipt: GoalTerminalReceipt, contract: GoalAcceptanceContract | null, observation: DebriefObservation | undefined, records?: readonly GoalFlightEventRecord[]): Debrief;
 export declare function renderDebrief(debrief: Debrief | undefined): string[];
+export declare function renderDebriefProof(debrief: Debrief | undefined): {
+    validation: string;
+    review: string;
+};
 export {};

package/dist/plugin/sortie-debrief.js

@@ -254,6 +254,12 @@ export function buildDebrief(receipt, contract, observation, records) {
                 wallMilliseconds: unionDuration(spans) } } : {}) };
 }
 const label = (text) => text.replace(/[\r\n\t]/gu, " ").replace(/[\\`*_{}\[\]()<>!|]/gu, "").slice(0, 120);
+const gauge = (percent) => {
+    const eighths = Math.max(0, Math.min(80, Math.round(percent * 0.8)));
+    const whole = Math.floor(eighths / 8), remainder = eighths % 8;
+    const partial = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"][remainder];
+    return `${"█".repeat(whole)}${partial}${" ".repeat(10 - whole - (remainder === 0 ? 0 : 1))}`;
+};
 export function renderDebrief(debrief) {
     const pack = debrief?.pack == null ? null : [...debrief.pack].sort((a, b) => b.count - a.count || a.model.localeCompare(b.model));
     const packVisible = pack?.slice(0, 4) ?? [];
@@ -264,21 +270,24 @@ export function renderDebrief(debrief) {
     if (mix !== null && mix.length > 4)
         visible.push({ model: "その他", tokens: mix.slice(4).reduce((sum, entry) => sum + entry.tokens, 0),
             percent: mix.slice(4).reduce((sum, entry) => sum + entry.percent, 0) });
-    const bars = (percent) => {
-        const filled = Math.max(0, Math.min(10, Math.round(percent / 10)));
-        return "█".repeat(filled) + "░".repeat(10 - filled);
-    };
-    const status = (value) => value === "PASS" ? "🟢 **PASS**" : value === "FAIL" ? "🔴 **FAIL**"
+    const status = (value) => value === "PASS" ? "🟢 PASS" : value === "FAIL" ? "🔴 FAIL"
         : value === "WAIVED" ? "免除" : "未記録";
+    const counts = new Map(packVisible.map((entry) => [entry.model, entry.count]));
     return [
-        `**🐕 出撃隊:** ${pack === null ? "履歴未取得" : pack.length === 0 ? "出撃なし" : packVisible.map((entry) => `${label(entry.model)} **×${entry.count}**`).join(" · ")}`,
-        `**モデル別token内訳:** ${mix === null ? "usage未取得" : ""}`,
-        ...visible.map((entry) => `**↳** ${label(entry.model)} \`${bars(entry.percent)}\` ${entry.percent.toFixed(1)}%`),
-        `**実行重複率:** ${debrief?.overlap !== undefined && debrief.overlap.wallMilliseconds > 0
-            ? `**${(debrief.overlap.workerMilliseconds / debrief.overlap.wallMilliseconds).toFixed(2)}×**（worker区間・速度倍率ではありません）`
+        ...(mix === null ? ["モデル内訳    usage未取得"] : visible.map((entry) => {
+            const count = counts.get(entry.model);
+            return `🐕 ${label(entry.model)} ${gauge(entry.percent)} ${entry.percent.toFixed(1)}% ${entry.tokens.toLocaleString("ja-JP")} tokens${count === undefined ? "" : ` ×${count}`}`;
+        })),
+        `⚡ 実行重複率 ${debrief?.overlap !== undefined && debrief.overlap.wallMilliseconds > 0
+            ? `${(debrief.overlap.workerMilliseconds / debrief.overlap.wallMilliseconds).toFixed(2)}×`
             : pack?.length === 0 ? "対象なし（出撃なし）" : "稼働区間の記録不足"}`,
-        `**確認:** 対象検証 ${status(debrief?.validation ?? "未確認")} · 直近Review ${status(debrief?.review ?? "未確認")}${debrief?.reviewSource === "reviewer" ? "（reviewer報告）" : ""}`,
-        ...(debrief?.notes?.length ? [`**計測範囲:** ${debrief.notes.join(" · ")}`] : []),
-        ...(debrief?.traits.length ? [`**🏅 今回の戦績:** ${debrief.traits.join(" · ")}`] : []),
+        "   ※worker区間・速度倍率ではありません",
+        ...(debrief?.notes?.length ? [`計測範囲      ${debrief.notes.join(" · ")}`] : []),
     ];
 }
+export function renderDebriefProof(debrief) {
+    const status = (value) => value === "PASS" ? "🟢 PASS" : value === "FAIL" ? "🔴 FAIL"
+        : value === "WAIVED" ? "免除" : "未記録";
+    return { validation: status(debrief?.validation ?? "未確認"),
+        review: `${status(debrief?.review ?? "未確認")}${debrief?.reviewSource === "reviewer" ? "（reviewer報告）" : ""}` };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.9.11",
+  "version": "0.9.12",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",