sortie-dogs 0.13.19 → 0.13.21

package/dist/plugin/profiled.js

@@ -11,12 +11,12 @@ import { BUILT_IN_MODEL_CATALOG } from "./model-routing.js";
 import { goalFingerprint } from "../core/goal-bound.js";
 import { decoratePreviewHeadings, returnReportPanel } from "./receipt-presentation.js";
 import { sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
-import { normalizeCommand, canonicalObservedValidationMembers, extractWritePaths } from "./gate.js";
+import { normalizeCommand, canonicalObservedValidationMembers, extractWritePaths, isShellTool } from "./gate.js";
 import { normalizeExecutionScope, normalizeManifestScope, normalizeRelativePath } from "../core/path.js";
-import { OperatorMissionRuntime, missionAcceptanceSummary, missionPacket, missionPlan, missionReviewAccepted, missionReviewIndependent, missionReviewScope, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionComplete, missionExecutionStatus, missionOperationSummary, missionValidationCommand, missionReviewTraces, missionReviewVerdict, missionSelfRecheckReport } from "../core/operator-mission.js";
+import { OperatorMissionRuntime, missionAcceptanceSummary, missionPacket, missionPlan, missionReviewAccepted, missionReviewIndependent, missionReviewScope, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionComplete, missionExecutionRecoveryAction, missionExecutionStatus, missionOperationCommandMatch, missionOperationCommandDecorated, missionOperationDirectoryMatch, missionOperationSummary, missionValidationCommand, missionReviewTraces, missionReviewVerdict, missionSelfRecheckReport } from "../core/operator-mission.js";
 import { publishMissionProgress } from "./mission-progress.js";
 import { formatWorkQuantity, planWorkQuantity } from "../core/work-quantity.js";
-import { cachedWorkProgress, observeActorWork, workRootForActor } from "../core/work-quantity-observations.js";
+import { cachedWorkProgress, forgetWorkSession, observeActorWork, workRootForActor } from "../core/work-quantity-observations.js";
 import { serializeOperatorStatus } from "./operator-status-output.js";
 import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionDeliveryObservation, missionReviewBaseline, missionReviewSource, observedMissionValidation, observedMissionValidationSummary, missionReviewValidation, reviewerCorrectionValidation, reviewerCorrectionValidationFresh, validationDirectoryMatches } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
@@ -242,8 +242,14 @@ export function createProfiledPlugin(profile, assetVersion) {
             return observedMissionValidationSummary(validation, child, typeof nativeSession?.messages === "function"
                 ? () => session("messages", { path: { id: child }, query: { directory: input.directory } }) : undefined, notBefore, notBefore === undefined ? undefined : input.directory, direct?.unit.directExecution?.validationCwd ?? direct?.unit.unit.validation_cwd);
         }
-        async function reviewMessages(id, notBefore) {
-            const result = payload(await session(typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages", { path: { id }, query: { directory: input.directory, ...(notBefore ? { notBefore } : {}) } }));
+        async function reviewMessages(id, notBefore, requireAvailable = false) {
+            const method = typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages";
+            if (requireAvailable && typeof nativeSession?.[method] !== "function")
+                throw new Error("native-operation-history-api-unavailable");
+            const response = await session(method, { path: { id }, query: { directory: input.directory, ...(notBefore ? { notBefore } : {}) } });
+            const result = payload(response);
+            if (requireAvailable && (record(response) && response.error || !Array.isArray(result)))
+                throw new Error("native-operation-history-response-unavailable");
             return Array.isArray(result) ? result.filter(record) : [];
         }
         async function observedSessionModel(id) {
@@ -551,7 +557,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 // not by resetting the goal budget. This checkpoint grants no dispatch itself.
                 if (mission && (!["completed", "cancelled"].includes(mission.phase) ||
                     (mission.phase === "cancelled" && run))) {
-                    return JSON.stringify(missionPacket(mission, run));
+                    return JSON.stringify(missionPacket(mission, run, false));
                 }
                 return await operators.continuationCheckpoint(root) ?? await proposals.continuationCheckpoint(root);
             },
@@ -1617,6 +1623,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (mission) {
                     const budget = await control.currentBudget(root);
                     const run = await operators.read(root);
+                    mission = await reconcileMissionExecution(root, mission, run);
                     const completion = run?.phase === "awaiting-acceptance" ? await control.completionReadiness(root) : undefined;
                     const acceptanceSummary = await missionAcceptanceSummary(mission, run, operators, acceptanceValidationObservation);
                     const packet = { acceptance_summary: acceptanceSummary, ...missionDispatchPacket(mission, run), budget,
@@ -1635,6 +1642,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                         delete packet.task;
                         delete packet.coordinator_dispatch;
                     }
+                    const recoveryAction = missionExecutionRecoveryAction(mission);
+                    if (recoveryAction)
+                        packet.next_action = recoveryAction;
                     if (view === "progress")
                         return serializeOperatorStatus(missionProgress(mission, run, budget, packet));
                     return serializeOperatorStatus(view === "full" ? packet : compactMissionEvidence(packet, run, root));
@@ -1766,10 +1776,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await requireRoot(context.sessionID);
                 const state = await operators.required(context.sessionID);
                 let mission = await missions.read(context.sessionID);
+                if (mission)
+                    mission = await reconcileMissionExecution(context.sessionID, mission, state);
                 if (mission?.kind === "operation" && !missionExecutionComplete(mission))
                     return JSON.stringify({
                         status: "not-ready", operation_status: missionExecutionStatus(mission),
-                        next_action: "The requested operation has not completed. Preserve its real outcome; auxiliary checks and a bounded review do not complete it. Continue the declared operation or report its blocker.",
+                        next_action: missionExecutionRecoveryAction(mission) ?? "The requested operation has not completed. Preserve its real outcome; auxiliary checks and a bounded review do not complete it. Continue the declared operation or report its blocker.",
                         packet: missionPacket(mission, state)
                     });
                 if (mission && !["completed", "cancelled"].includes(mission.phase))
@@ -2518,6 +2530,225 @@ export function createProfiledPlugin(profile, assetVersion) {
             const commands = [...new Set(execution.commands.map(missionValidationCommand).map(normalizeCommand))];
             return { commands, directory: resolve(input.directory, execution.directory), observations: operation?.observations ?? [] };
         }
+        async function reconcileMissionExecution(root, mission, run) {
+            const execution = mission.execution;
+            if (mission.kind !== "operation" || !execution || !run || run.runID !== mission.runID ||
+                ["completed", "cancelled"].includes(mission.phase))
+                return mission;
+            const owners = new Map();
+            const recoveryErrors = [];
+            const addOwner = (actor, window) => owners.set(actor, [...(owners.get(actor) ?? []), window]);
+            for (const unit of run.units) {
+                if (unit.directExecution?.actor) {
+                    addOwner(unit.directExecution.actor, { notBefore: unit.directExecution.startedAt,
+                        ...(unit.directExecution.finishedAt ? { notAfter: unit.directExecution.finishedAt } : {}) });
+                    continue;
+                }
+                const child = unit.childSessionID;
+                if (!child || !unit.callID)
+                    continue;
+                const attempt = mission.attempts?.find(item => item.runID === run.runID && item.unitID === unit.unit.id &&
+                    item.callID === unit.callID && item.childSessionID === child);
+                if (!attempt || attempt.status === "pending")
+                    continue;
+                let info;
+                try {
+                    const response = await session("get", { path: { id: child }, query: { directory: input.directory } });
+                    const value = payload(response);
+                    if (!record(value) || record(response) && response.error)
+                        throw new Error("native-operation-session-unavailable");
+                    info = value;
+                }
+                catch (error) {
+                    recoveryErrors.push({ sessionID: child, reason: error instanceof Error ? error.message : String(error) });
+                    continue;
+                }
+                if (info.id !== undefined && info.id !== child || info.parentID !== (run.operatorSessionID ?? root))
+                    continue;
+                const created = record(info.time) ? info.time.created : undefined;
+                const createdAt = typeof created === "number" && Number.isFinite(created) ? created
+                    : typeof created === "string" ? Date.parse(created) : NaN;
+                // A reusable correction author belongs to this admission, not every earlier turn
+                // since the conversation was created. Ordinary Workers have a new native session.
+                const admittedAt = Date.parse(unit.reviewerCorrection?.admittedAt ?? run.createdAt);
+                const settled = unit.reviewerCorrection && ["succeeded", "failed", "cancelled"].includes(unit.status)
+                    ? [...mission.progress].reverse().find(item => item.unit === `${run.runID}/${unit.unit.id}` &&
+                        ["succeeded", "failed", "cancelled"].includes(item.status) && Number.isFinite(Date.parse(item.at)))?.at
+                    : undefined;
+                // The correction session is reusable after settlement; its later turns are
+                // not this unit's operation. Reuse the existing recorded settlement boundary.
+                if (unit.reviewerCorrection && unit.status !== "running" && !settled)
+                    continue;
+                if (Number.isFinite(createdAt) && Number.isFinite(admittedAt)) {
+                    addOwner(child, { notBefore: new Date(Math.max(createdAt, admittedAt)).toISOString(),
+                        ...(settled ? { notAfter: settled } : {}) });
+                }
+            }
+            if (owners.size === 0 && recoveryErrors.length === 0)
+                return mission;
+            const recovered = [];
+            const observedInputs = [];
+            const conflictingCalls = [];
+            const laterStart = (saved, observed) => !saved || Date.parse(observed) > Date.parse(saved) ? observed : saved;
+            for (const [sessionID, windows] of owners) {
+                // A direct session has its own native admission time; a delegated session is bounded
+                // by its native creation time when exposed by the existing session API.
+                const notBefore = windows.map(window => window.notBefore).sort()[0];
+                if (!notBefore)
+                    continue;
+                let history;
+                try {
+                    history = await reviewMessages(sessionID, notBefore, true);
+                }
+                catch (error) {
+                    recoveryErrors.push({ sessionID, reason: error instanceof Error ? error.message : String(error) });
+                    continue;
+                }
+                const calls = new Map();
+                const conflicts = new Set();
+                const nativeStarts = new Map();
+                const nativeInputs = new Map();
+                for (const message of history) {
+                    const info = record(message.info) ? message.info : message;
+                    if (info.role !== "assistant" || info.sessionID !== sessionID || !Array.isArray(message.parts))
+                        continue;
+                    for (const part of message.parts) {
+                        if (!record(part) || part.type !== "tool" || !isShellTool(String(part.tool)) ||
+                            (part.sessionID !== undefined && part.sessionID !== sessionID) || typeof part.callID !== "string" ||
+                            !record(part.state) || !record(part.state.input))
+                            continue;
+                        const state = part.state;
+                        const nativeInput = state.input;
+                        if (typeof nativeInput.command !== "string")
+                            continue;
+                        const time = record(state.time) ? state.time : record(part.time) ? part.time : {};
+                        const date = (value) => typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString()
+                            : typeof value === "string" && Number.isFinite(Date.parse(value)) ? new Date(value).toISOString() : undefined;
+                        const startedAt = date(time.start ?? time.ran);
+                        if (!startedAt)
+                            continue;
+                        // A boundary page may include tools from a later reusable-session turn.
+                        // Ignore them before comparing call input or terminal state as well.
+                        if (!windows.some(window => Date.parse(startedAt) >= Date.parse(window.notBefore) &&
+                            (!window.notAfter || Date.parse(startedAt) <= Date.parse(window.notAfter))))
+                            continue;
+                        const nativeDirectory = resolve(input.directory, typeof nativeInput.workdir === "string" ? nativeInput.workdir : ".");
+                        const directory = missionOperationDirectoryMatch(nativeDirectory, execution.directory) ? execution.directory : nativeDirectory;
+                        const key = part.callID;
+                        nativeStarts.set(key, laterStart(nativeStarts.get(key), startedAt));
+                        const nativeInputIdentity = { command: nativeInput.command, directory };
+                        const priorInput = nativeInputs.get(key);
+                        if (priorInput && (priorInput.command !== nativeInput.command || priorInput.directory !== directory)) {
+                            conflicts.add(key);
+                        }
+                        nativeInputs.set(key, nativeInputIdentity);
+                        const command = missionOperationCommandMatch(nativeInput.command, execution.commands, execution.directory);
+                        // Compare admitted inputs with persisted same-call observations even when this
+                        // record is no longer a matching command/cwd and will not yield a new result.
+                        observedInputs.push({ sessionID, callID: key, command, directory, startedAt });
+                        if (directory !== execution.directory)
+                            continue;
+                        if (!command)
+                            continue;
+                        const metadata = record(state.metadata) ? state.metadata : {};
+                        const nativeStatus = String(state.status ?? "").toLowerCase();
+                        const resultStatus = String(metadata.status ?? "").toLowerCase();
+                        if ((nativeStatus === "error" && resultStatus === "running") || (nativeStatus === "running" && resultStatus === "error")) {
+                            conflicts.add(key);
+                        }
+                        const running = nativeStatus === "running" || resultStatus === "running";
+                        const failed = nativeStatus === "error" || resultStatus === "error";
+                        if (!["completed", "error", "running"].includes(nativeStatus))
+                            continue;
+                        if (!running && !failed && nativeStatus !== "completed")
+                            continue;
+                        const completedAt = running ? undefined : date(time.end ?? time.completed);
+                        const exit = Number.isSafeInteger(metadata.exit) ? metadata.exit : undefined;
+                        const output = typeof state.output === "string" ? state.output : typeof part.output === "string" ? part.output : "";
+                        const status = failed ? "error" : running ? "running" : "completed";
+                        const outcome = conflicts.has(key) || running || !completedAt || exit === undefined ? undefined : missionCommandOutcome(output, exit, status);
+                        // A completed tool envelope without an exit/result does not prove a successful
+                        // process. Keep it unclassified instead of turning missing metadata into success.
+                        if (nativeInput.background === true && !running)
+                            continue;
+                        const observation = { command, directory: execution.directory, callID: key, sessionID, startedAt, nativeStartedAt: startedAt,
+                            ...(completedAt ? { completedAt } : {}), ...(exit === undefined ? {} : { exit }), status,
+                            ...(typeof metadata.shellID === "string" ? { shellID: metadata.shellID } : {}), ...(outcome ?? {}) };
+                        const prior = calls.get(key);
+                        if (prior && (prior.command !== command || prior.directory !== directory || prior.observation.startedAt !== startedAt ||
+                            prior.observation.completedAt && observation.completedAt && (prior.observation.status !== status ||
+                                prior.observation.completedAt !== observation.completedAt ||
+                                prior.observation.exit !== undefined && exit !== undefined && prior.observation.exit !== exit ||
+                                prior.observation.outcome !== undefined && observation.outcome !== undefined && JSON.stringify(prior.observation) !== JSON.stringify(observation)))) {
+                            conflicts.add(key);
+                        }
+                        else if (!prior || !conflicts.has(key) && (prior.observation.outcome === undefined || observation.outcome !== undefined)) {
+                            calls.set(key, { command, directory, observation });
+                        }
+                    }
+                }
+                for (const [callID, item] of calls)
+                    recovered.push({ ...item.observation, ...(conflicts.has(callID)
+                            ? { conflicting: true, latestConflictingStartedAt: nativeStarts.get(callID) } : {}) });
+                for (const callID of conflicts)
+                    conflictingCalls.push({ sessionID, callID, latestConflictingStartedAt: nativeStarts.get(callID) });
+            }
+            if (recovered.length === 0 && conflictingCalls.length === 0 && observedInputs.length === 0 && recoveryErrors.length === 0 && !execution.recovery)
+                return mission;
+            return missions.update(root, current => {
+                if (current.runID !== mission.runID || current.kind !== "operation" || !current.execution ||
+                    ["completed", "cancelled"].includes(current.phase) ||
+                    current.execution.directory !== execution.directory || JSON.stringify(current.execution.commands) !== JSON.stringify(execution.commands))
+                    return;
+                if (recoveryErrors.length)
+                    current.execution.recovery = { status: "unavailable", errors: recoveryErrors };
+                else
+                    delete current.execution.recovery;
+                for (const nativeInput of observedInputs) {
+                    const prior = current.execution.observations.find(item => item.callID === nativeInput.callID && item.sessionID === nativeInput.sessionID);
+                    if (prior && (prior.command !== nativeInput.command || prior.directory !== nativeInput.directory)) {
+                        prior.conflicting = true;
+                        prior.latestConflictingStartedAt = laterStart(prior.latestConflictingStartedAt ?? prior.nativeStartedAt, nativeInput.startedAt);
+                    }
+                }
+                for (const observation of recovered) {
+                    const prior = current.execution.observations.find(item => item.callID === observation.callID && item.sessionID === observation.sessionID);
+                    if (!prior) {
+                        current.execution.observations.push(observation);
+                        continue;
+                    }
+                    if (prior.command !== observation.command || prior.directory !== observation.directory)
+                        continue;
+                    if (observation.conflicting || prior.nativeStartedAt !== undefined && prior.nativeStartedAt !== observation.nativeStartedAt ||
+                        prior.completedAt && observation.completedAt && (prior.status !== observation.status ||
+                            prior.exit !== undefined && observation.exit !== undefined && prior.exit !== observation.exit ||
+                            prior.outcome !== undefined && observation.outcome !== undefined && prior.outcome !== observation.outcome)) {
+                        prior.conflicting = true;
+                    }
+                    if (prior.conflicting)
+                        prior.latestConflictingStartedAt = laterStart(prior.latestConflictingStartedAt ?? prior.nativeStartedAt, observation.latestConflictingStartedAt ?? observation.nativeStartedAt);
+                    prior.nativeStartedAt ??= observation.nativeStartedAt;
+                    if (prior.outcome !== undefined)
+                        continue;
+                    const latestConflictingStartedAt = prior.latestConflictingStartedAt;
+                    const nativeStartedAt = prior.nativeStartedAt;
+                    delete prior.completedAt;
+                    delete prior.exit;
+                    delete prior.outcome;
+                    delete prior.result;
+                    Object.assign(prior, observation, { startedAt: prior.startedAt,
+                        ...(nativeStartedAt ? { nativeStartedAt } : {}),
+                        ...(latestConflictingStartedAt ? { latestConflictingStartedAt } : {}) });
+                }
+                for (const conflict of conflictingCalls) {
+                    const prior = current.execution.observations.find(item => item.callID === conflict.callID && item.sessionID === conflict.sessionID);
+                    if (prior) {
+                        prior.conflicting = true;
+                        prior.latestConflictingStartedAt = laterStart(prior.latestConflictingStartedAt ?? prior.nativeStartedAt, conflict.latestConflictingStartedAt);
+                    }
+                }
+            });
+        }
         async function declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID, handoffNotes, workQuantities) {
             await control.currentBudget(root);
             mission = await missions.required(root);
@@ -3186,13 +3417,14 @@ export function createProfiledPlugin(profile, assetVersion) {
             args: { status: { type: "string", enum: ["ready", "needs-decision", "blocked"] }, summary: stringSchema }, execute: async (args, context) => {
                 const { root } = await missionAuthority(context.sessionID);
                 return serializeDispatchTransition(root, async () => {
-                    const mission = await missions.required(root);
+                    let mission = await missions.required(root);
+                    mission = await reconcileMissionExecution(root, mission, await operators.read(root));
                     if (args.status === "ready") {
                         if (mission.kind === "operation" && !missionExecutionComplete(mission)) {
                             return JSON.stringify({ ...missionPacket(mission, await operators.read(root)), status: "operation-incomplete",
-                                next_action: missionExecutionStatus(mission) === "running"
+                                next_action: missionExecutionRecoveryAction(mission) ?? (missionExecutionStatus(mission) === "running"
                                     ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
-                                    : "Continue the requested operation or submit its actual blocker. A successful setup/NO_START check does not authorize ready." });
+                                    : "Continue the requested operation or submit its actual blocker. A successful setup/NO_START check does not authorize ready.") });
                         }
                         const run = await operators.required(root);
                         if (run.phase !== "awaiting-acceptance")
@@ -3215,7 +3447,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                         ...compactMissionEvidence(missionPacket(updated, submittedRun), submittedRun, root),
                         next_action: args.status === "ready"
                             ? "Return this result and acceptance_summary to Operator now. Compare the original requests with the candidate and actual evidence; inspect concrete gaps only, then complete_mission if satisfied. No routine archive search or full source reread. Completion still requires its final comparison and complete_mission receipt."
-                            : "Return the saved blocker or user-only decision to Operator now. This is incomplete delivery, not acceptance; retain the candidate, failed checks and cumulative spend. Do not repeat unchanged work or dispatch a replacement merely to finalize this result." });
+                            : ["Return the saved blocker or user-only decision to Operator now. This is incomplete delivery, not acceptance; retain the candidate, failed checks and cumulative spend. Do not repeat unchanged work or dispatch a replacement merely to finalize this result.",
+                                missionExecutionRecoveryAction(updated)].filter(Boolean).join(" ") });
                 });
             } };
         tools[completeMission] = { description: "Operator only: after comparing the original request, source, actual checks and current review disposition (explicit native author self-recheck is not independent PASS), explicitly accept the whole mission. A collected terminal failure can satisfy a run-once/report request, not a request for successful execution. Returns operation outcome separately from the measured 🐾 Mission receipt; never treat Worker start, CORRECTION_READY or one passing check as completion.",
@@ -3872,17 +4105,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const operationArgs = record(mapped.args) ? mapped.args : {};
                     // A decorated launch would spend on the real operation but leave the native mission observation empty.
                     // Ask the same Worker to correct its shell input before that expensive side effect.
-                    if (writer && ["bash", "shell"].includes(request.tool.toLowerCase()) && mission?.execution &&
+                    if (writer && isShellTool(request.tool) && mission?.execution &&
                         typeof operationArgs.command === "string" &&
-                        resolve(input.directory, typeof operationArgs.workdir === "string" ? operationArgs.workdir : ".") === mission.execution.directory) {
-                        const actual = normalizeCommand(operationArgs.command);
-                        if (operationArgs.background === true && mission.execution.commands.includes(actual)) {
+                        missionOperationDirectoryMatch(resolve(input.directory, typeof operationArgs.workdir === "string" ? operationArgs.workdir : "."), mission.execution.directory)) {
+                        const declaredOperation = missionOperationCommandMatch(operationArgs.command, mission.execution.commands, mission.execution.directory);
+                        if (operationArgs.background === true && declaredOperation !== undefined) {
                             throw new Error("mission-operation-background: run the declared command in foreground with a suitable timeout. " +
                                 "A background shell reports only launch, not process exit; no run was started by this refused call. " +
                                 "Correct this same Worker command without a new plan or approval.");
                         }
-                        const decorated = mission.execution.commands.some(declared => actual.startsWith(declared) &&
-                            /^\s*(?:\||\d?>|&&?|;)/u.test(actual.slice(declared.length)));
+                        const decorated = missionOperationCommandDecorated(operationArgs.command, mission.execution.commands, mission.execution.directory);
                         if (decorated)
                             throw new Error("mission-operation-command-not-observed: run the declared operation command exactly; " +
                                 "do not append a pipe, tee, redirection or chained command. Capture its tool output or write a separate result file afterward. " +
@@ -3926,16 +4158,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                     }
                     else
                         Object.assign(output, outward);
-                    if (writer && ["bash", "shell"].includes(request.tool) && mission?.execution &&
-                        typeof args.command === "string" && mission.execution.commands.includes(normalizeCommand(args.command)) &&
-                        resolve(input.directory, typeof args.workdir === "string" ? args.workdir : ".") === mission.execution.directory) {
-                        const command = normalizeCommand(args.command);
-                        await missions.update(root, item => {
-                            if (!item.execution.observations.some(observation => observation.callID === request.callID)) {
-                                item.execution.observations.push({ command, directory: item.execution.directory,
-                                    callID: request.callID, sessionID: request.sessionID, startedAt: new Date().toISOString() });
-                            }
-                        });
+                    if (writer && isShellTool(request.tool) && mission?.execution &&
+                        typeof args.command === "string" && missionOperationDirectoryMatch(resolve(input.directory, typeof args.workdir === "string" ? args.workdir : "."), mission.execution.directory)) {
+                        const command = missionOperationCommandMatch(args.command, mission.execution.commands, mission.execution.directory);
+                        if (command !== undefined)
+                            await missions.update(root, item => {
+                                if (!item.execution.observations.some(observation => observation.callID === request.callID)) {
+                                    item.execution.observations.push({ command, directory: item.execution.directory,
+                                        callID: request.callID, sessionID: request.sessionID, startedAt: new Date().toISOString() });
+                                }
+                            });
                     }
                 }
                 catch (error) {
@@ -4192,7 +4424,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await core["tool.execute.after"]?.({ ...translate(request, false),
                     ...(ownership ? { sessionID: ownership.root } : {}) }, mapped);
                 Object.assign(output, translate(mapped, true));
-                if (!ownership && ["bash", "shell"].includes(request.tool.toLowerCase())) {
+                if (!ownership && isShellTool(request.tool)) {
                     const root = await rootFor(id);
                     const mission = root ? await missions.read(root) : undefined;
                     if (root && mission?.execution?.observations.some(item => item.callID === request.callID && item.sessionID === id)) {
@@ -4211,7 +4443,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                             observation.status = output.status === "error" || metadata.status === "error" ? "error" : "completed";
                             if (Number.isSafeInteger(metadata.exit))
                                 observation.exit = metadata.exit;
-                            Object.assign(observation, missionCommandOutcome(returnedOutput, metadata.exit, observation.status));
+                            if (Number.isSafeInteger(metadata.exit)) {
+                                Object.assign(observation, missionCommandOutcome(returnedOutput, metadata.exit, observation.status));
+                            }
                         });
                     }
                 }
@@ -4489,42 +4723,48 @@ export function createProfiledPlugin(profile, assetVersion) {
                             : event.type.startsWith("session.") && typeof info?.id === "string" ? info.id : undefined;
                 if (!id)
                     return;
-                if (event.type === "session.deleted" && canonicalAgent(profile, selected.get(id)) === "dog-coordinator") {
-                    await stop(id, "session-deleted");
-                    return;
-                }
-                if (!await rootFor(id))
-                    return;
-                const mappedEvent = translate({ event }, false);
-                const mappedPart = record(mappedEvent.event.properties?.part) ? mappedEvent.event.properties.part : undefined;
-                if ((await identity(id)).role === "dog-coordinator" && mappedPart?.type === "text" && typeof mappedPart.text === "string") {
-                    mappedPart.text = forwardTerminalText(mappedPart.text);
-                }
-                await core.event?.(mappedEvent);
-                if (event.type === "message.updated" && info)
-                    await renderCompletedReply(id, info);
-                if (event.type === "message.part.updated" && part?.type === "tool" && part.tool === "task" &&
-                    typeof part.callID === "string" && record(part.state) && part.state.status === "error") {
-                    const ownership = taskOwners.get(part.callID);
-                    if (ownership !== undefined && ownership.actor === id) {
-                        if (ownership.mission) {
-                            await missions.update(ownership.root, state => { state.dispatchOpen = false; });
-                            taskOwners.delete(part.callID);
-                            return;
-                        }
-                        if (ownership.consultation) {
-                            taskOwners.delete(part.callID);
-                            return;
+                try {
+                    if (event.type === "session.deleted" && canonicalAgent(profile, selected.get(id)) === "dog-coordinator") {
+                        await stop(id, "session-deleted");
+                        return;
+                    }
+                    if (!await rootFor(id))
+                        return;
+                    const mappedEvent = translate({ event }, false);
+                    const mappedPart = record(mappedEvent.event.properties?.part) ? mappedEvent.event.properties.part : undefined;
+                    if ((await identity(id)).role === "dog-coordinator" && mappedPart?.type === "text" && typeof mappedPart.text === "string") {
+                        mappedPart.text = forwardTerminalText(mappedPart.text);
+                    }
+                    await core.event?.(mappedEvent);
+                    if (event.type === "message.updated" && info)
+                        await renderCompletedReply(id, info);
+                    if (event.type === "message.part.updated" && part?.type === "tool" && part.tool === "task" &&
+                        typeof part.callID === "string" && record(part.state) && part.state.status === "error") {
+                        const ownership = taskOwners.get(part.callID);
+                        if (ownership !== undefined && ownership.actor === id) {
+                            if (ownership.mission) {
+                                await missions.update(ownership.root, state => { state.dispatchOpen = false; });
+                                taskOwners.delete(part.callID);
+                                return;
+                            }
+                            if (ownership.consultation) {
+                                taskOwners.delete(part.callID);
+                                return;
+                            }
+                            const settled = ownership.proposal
+                                ? (await control.settleProposalBudget(ownership.root, (await proposals.required(ownership.root)).intent_id, part.callID, "failed"), true)
+                                : ownership.operator
+                                    ? (await operators.operatorRejected(ownership.root), true)
+                                    : await control?.settleRejectedDispatch(ownership.root, part.callID) ?? false;
+                            if (settled)
+                                taskOwners.delete(part.callID);
                         }
-                        const settled = ownership.proposal
-                            ? (await control.settleProposalBudget(ownership.root, (await proposals.required(ownership.root)).intent_id, part.callID, "failed"), true)
-                            : ownership.operator
-                                ? (await operators.operatorRejected(ownership.root), true)
-                                : await control?.settleRejectedDispatch(ownership.root, part.callID) ?? false;
-                        if (settled)
-                            taskOwners.delete(part.callID);
                     }
                 }
+                finally {
+                    if (event.type === "session.deleted")
+                        forgetWorkSession(input.directory, id);
+                }
             },
         };
         const before = hooks["tool.execute.before"];