@zq-silk/yui 0.16.1 → 0.16.2

package/dist/runtime/structuredProviderHost.js

@@ -7,7 +7,7 @@ import WebSocket from "ws";
 import { YUI_VERSION } from "../version.js";
 import { AcpStructuredProviderSession } from "./acpSession.js";
 import { acpDesiredSessionConfiguration } from "./acpSessionConfiguration.js";
-import { serializeAgentErrorRaw } from "./agentError.js";
+import { providerDeliveryFailureFrom, serializeAgentErrorRaw } from "./agentError.js";
 import { unsupportedAgentRunConfiguration } from "./agentRunConfiguration.js";
 import { codexAppServerErrorIsMissing, CodexAppServerRequestError, CodexAppServerRuntime, codexClientInitialization, codexGoalNotification, codexTurnInput, codexTurnOutput } from "./codexAppServerRuntime.js";
 import { JsonLineChannel, PROVIDER_MESSAGE_MAX_BYTES, terminateProcessGroup } from "./jsonLineChannel.js";
@@ -65,6 +65,7 @@ export async function startStructuredProviderSession(payload, input = {}) {
                     ? {}
                     : { nativeSessionId: control.nativeSessionId }),
                 ...(input.onTerminal === undefined ? {} : { onTerminal: input.onTerminal }),
+                ...(input.onDiagnostic === undefined ? {} : { onDiagnostic: input.onDiagnostic }),
                 mirror
             });
             return Object.freeze({ session });
@@ -79,7 +80,7 @@ export async function startStructuredProviderSession(payload, input = {}) {
                 goal: opened.goal
             });
         }
-        const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onAccepted, input.onTerminal, input.onGoal, input.onActivity, mirror);
+        const session = await ClaudeStructuredProviderSession.open(child, exit, processInstanceId, control, input.onAccepted, input.onTerminal, input.onGoal, input.onActivity, input.onDiagnostic, mirror);
         return Object.freeze({ session });
     }
     catch (error) {
@@ -325,6 +326,7 @@ class CodexStructuredProviderSession {
     onGoal;
     onInput;
     onActivity;
+    mirror;
     nativeAccountHome;
     #turnAttempts = new Map();
     adapterId = "codex";
@@ -335,7 +337,7 @@ class CodexStructuredProviderSession {
     #bufferedStarts = [];
     #bufferedTerminals = [];
     #bufferedActivities = [];
-    constructor(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, nativeAccountHome) {
+    constructor(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, nativeAccountHome) {
         this.child = child;
         this.exit = exit;
         this.processInstanceId = processInstanceId;
@@ -346,6 +348,7 @@ class CodexStructuredProviderSession {
         this.onGoal = onGoal;
         this.onInput = onInput;
         this.onActivity = onActivity;
+        this.mirror = mirror;
         this.nativeAccountHome = nativeAccountHome;
     }
     static async open(child, exit, processInstanceId, payload, control, onStarted, onTerminal, onGoal, onInput, onActivity, mirror) {
@@ -387,7 +390,7 @@ class CodexStructuredProviderSession {
                 name: control.sessionTitle
             });
         }
-        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, optionalId(initialized.codexHome));
+        const session = new CodexStructuredProviderSession(child, exit, processInstanceId, conversationId, runtime, onStarted, onTerminal, onGoal, onInput, onActivity, mirror, optionalId(initialized.codexHome));
         session.#activeTurnId = resumedActiveTurnId;
         const ownedTurn = control.kind === "restore" ? control.ownedTurn : undefined;
         session.#clientOwnedTurnId = ownedTurn?.turnId;
@@ -445,9 +448,21 @@ class CodexStructuredProviderSession {
     #observeMessage(message, emit) {
         const method = typeof message.method === "string" ? message.method : "";
         const params = object(message.params) ?? {};
-        if (optionalId(params.threadId) !== this.conversationId)
+        const threadId = optionalId(params.threadId);
+        if (threadId !== this.conversationId) {
+            if (threadId === undefined && (method === "turn/started" || method === "turn/completed")) {
+                this.mirror("stderr", `Codex protocol: ${method} has no thread identity; ignored.\n`);
+            }
             return undefined;
-        const goal = codexGoalNotification({ method, params });
+        }
+        let goal;
+        try {
+            goal = codexGoalNotification({ method, params });
+        }
+        catch {
+            this.mirror("stderr", "Codex protocol: invalid Goal notification; ignored.\n");
+            return undefined;
+        }
         if (goal !== undefined) {
             if (emit)
                 this.onGoal?.(goal);
@@ -456,17 +471,20 @@ class CodexStructuredProviderSession {
         if (emit && (method === "item/started" || method === "item/completed"
             || method === "item/agentMessage/delta" || method === "item/reasoning/summaryTextDelta")) {
             const item = object(params.item);
-            const id = optionalId(item?.id) ?? optionalId(params.itemId);
+            const delta = method === "item/agentMessage/delta" || method === "item/reasoning/summaryTextDelta";
+            const id = optionalId(delta ? params.itemId : item?.id);
             const nativeTurnId = optionalId(params.turnId);
-            const tool = ["commandExecution", "mcpToolCall", "dynamicToolCall", "fileChange"].includes(String(item?.type));
-            const model = ["agentMessage", "reasoning"].includes(String(item?.type)) || method.endsWith("Delta") || method.endsWith("/delta");
-            if (id !== undefined && nativeTurnId !== undefined && (tool || model)) {
+            const tool = typeof item?.type === "string"
+                && ["commandExecution", "mcpToolCall", "dynamicToolCall", "fileChange"].includes(item.type);
+            const model = delta || item?.type === "agentMessage" || item?.type === "reasoning";
+            const phase = model ? "model" : tool ? codexToolPhase(item, method === "item/started") : undefined;
+            if (tool && phase === undefined) {
+                this.mirror("stderr", "Codex protocol: tool item has no valid lifecycle status; ignored.\n");
+            }
+            if (id !== undefined && nativeTurnId !== undefined && phase !== undefined) {
                 const activity = {
                     conversationId: this.conversationId, nativeSessionId: this.conversationId,
-                    nativeTurnId, id, observedAt: new Date().toISOString(),
-                    phase: model ? "model" : method === "item/started" ? "started"
-                        : item?.status === "failed" || (typeof item?.exitCode === "number" && item.exitCode !== 0)
-                            ? "failed" : "completed"
+                    nativeTurnId, id, observedAt: new Date().toISOString(), phase
                 };
                 if (this.#submissionPending)
                     this.#bufferedActivities.push(activity);
@@ -486,10 +504,10 @@ class CodexStructuredProviderSession {
             return undefined;
         }
         if (method === "turn/started") {
-            const turnId = nestedId(params, "turn") ?? optionalId(params.turnId);
-            if (turnId !== undefined) {
+            const turn = object(params.turn);
+            const turnId = optionalId(turn?.id);
+            if (turnId !== undefined && turn?.status === "inProgress") {
                 this.#activeTurnId = turnId;
-                const turn = object(params.turn) ?? {};
                 const input = codexTurnInput(turn);
                 const started = {
                     conversationId: this.conversationId,
@@ -503,14 +521,20 @@ class CodexStructuredProviderSession {
                 else if (emit)
                     this.#emitStarted(started);
             }
+            else {
+                this.mirror("stderr", "Codex protocol: turn/started has no valid Turn identity/status; ignored.\n");
+            }
             return undefined;
         }
         if (method !== "turn/completed")
             return undefined;
-        const turn = object(params.turn) ?? {};
-        const nativeTurnId = optionalId(turn.id) ?? optionalId(params.turnId);
-        if (nativeTurnId === undefined)
+        const turn = object(params.turn);
+        const nativeTurnId = optionalId(turn?.id);
+        if (nativeTurnId === undefined || turn === null
+            || (turn.status !== "completed" && turn.status !== "failed" && turn.status !== "interrupted")) {
+            this.mirror("stderr", "Codex protocol: turn/completed has no valid terminal Turn identity/status; ignored.\n");
             return undefined;
+        }
         const status = turn.status === "failed"
             ? "failed"
             : turn.status === "interrupted" ? "cancelled" : "completed";
@@ -680,6 +704,7 @@ class ClaudeStructuredProviderSession {
     conversationId;
     channel;
     onGoal;
+    mirror;
     adapterId = "claude";
     get ownedProcessId() { return this.child.pid; }
     #activeAttemptId;
@@ -689,22 +714,33 @@ class ClaudeStructuredProviderSession {
     #openToolIds = new Set();
     #resultAttempts = new Map();
     #lastGoalKey;
-    constructor(child, exit, processInstanceId, conversationId, channel, onGoal) {
+    constructor(child, exit, processInstanceId, conversationId, channel, onGoal, mirror) {
         this.child = child;
         this.exit = exit;
         this.processInstanceId = processInstanceId;
         this.conversationId = conversationId;
         this.channel = channel;
         this.onGoal = onGoal;
+        this.mirror = mirror;
     }
-    static async open(child, exit, processInstanceId, control, onAccepted, onTerminal, onGoal, onActivity, mirror) {
-        const channel = new JsonLineChannel(child, mirror);
+    static async open(child, exit, processInstanceId, control, onAccepted, onTerminal, onGoal, onActivity, onDiagnostic, mirror) {
         const nativeSessionId = control.nativeSessionId;
         if (nativeSessionId === undefined) {
             throw new Error("Managed Claude launch requires a preallocated native Session id.");
         }
-        const session = new ClaudeStructuredProviderSession(child, exit, processInstanceId, nativeSessionId, channel, onGoal);
-        channel.onMessage((message) => session.#receive(message, onTerminal, onAccepted, onActivity));
+        let receivingAttemptId;
+        const channel = new JsonLineChannel(child, mirror, error => onDiagnostic?.({
+            nativeSessionId,
+            ...((receivingAttemptId ?? session.#activeAttemptId) === undefined
+                ? {} : { attemptId: receivingAttemptId ?? session.#activeAttemptId }),
+            failure: providerDeliveryFailureFrom(error, { phase: "turn-reconcile", inputDisposition: "unknown" })
+        }));
+        const session = new ClaudeStructuredProviderSession(child, exit, processInstanceId, nativeSessionId, channel, onGoal, mirror);
+        channel.onMessage((message) => {
+            receivingAttemptId = session.#activeAttemptId;
+            session.#receive(message, onTerminal, onAccepted, onActivity);
+            receivingAttemptId = undefined;
+        });
         // This client owns the whole Claude execution process, unlike a Codex
         // proxy. An exit without a result ends the exact local input as failure,
         // not as continuing work merely because the supervising Host is alive.
@@ -855,24 +891,35 @@ class ClaudeStructuredProviderSession {
             }
             return;
         }
-        if (message.type !== "result"
-            || optionalId(message.session_id) !== this.conversationId)
+        if (message.type !== "result")
             return;
+        const sessionId = optionalId(message.session_id);
+        if (sessionId !== this.conversationId) {
+            if (sessionId === undefined)
+                this.mirror("stderr", "Claude protocol: result has no Session identity; ignored.\n");
+            return;
+        }
         // A result UUID identifies this message, not the Provider execution.
         // Retain its local association so a delayed duplicate cannot be assigned
         // to a successor request on the same long-lived process.
         const resultId = optionalId(message.uuid);
-        const priorAttempt = resultId === undefined ? undefined : this.#resultAttempts.get(resultId);
+        const subtype = message.subtype;
+        const failed = subtype === "success" ? message.is_error
+            : ["error_during_execution", "error_max_turns", "error_max_budget_usd",
+                "error_max_structured_output_retries"].includes(String(subtype)) ? true : undefined;
+        if (resultId === undefined || typeof message.is_error !== "boolean" || failed === undefined) {
+            this.mirror("stderr", "Claude protocol: result has no valid identity/status; ignored.\n");
+            return;
+        }
+        const priorAttempt = this.#resultAttempts.get(resultId);
         const attemptId = priorAttempt ?? this.#activeAttemptId;
         if (attemptId === undefined)
             return;
-        if (resultId !== undefined)
-            this.#resultAttempts.set(resultId, attemptId);
+        this.#resultAttempts.set(resultId, attemptId);
         if (attemptId === this.#activeAttemptId) {
             this.#activeAttemptId = undefined;
             this.#openToolIds.clear();
         }
-        const failed = message.is_error === true || message.subtype === "error_during_execution";
         const result = typeof message.result === "string" && message.result.length > 0
             ? message.result
             : providerErrorEvidence(message).error;
@@ -891,64 +938,44 @@ class ClaudeStructuredProviderSession {
         });
     }
 }
+function codexToolPhase(item, started) {
+    if (started)
+        return item.status === "inProgress" ? "started" : undefined;
+    if (item.status === "failed")
+        return "failed";
+    if (item.status === "declined"
+        && (item.type === "commandExecution" || item.type === "fileChange"))
+        return "failed";
+    if (item.status !== "completed")
+        return undefined;
+    if (item.type === "commandExecution" && typeof item.exitCode === "number" && item.exitCode !== 0) {
+        return "failed";
+    }
+    if (item.type === "dynamicToolCall" && item.success === false)
+        return "failed";
+    return "completed";
+}
 function claudeActiveGoal(message, conversationId) {
-    if (!Object.hasOwn(message, "active_goal"))
+    if (message.type !== "active_goal" || optionalId(message.session_id) !== conversationId)
         return undefined;
-    if (message.active_goal === null)
+    if (message.value === null)
         return null;
-    const raw = object(message.active_goal);
+    const raw = object(message.value);
     if (raw === null)
         return undefined;
-    const objective = typeof raw.objective === "string" ? raw.objective.trim() : "";
+    const objective = typeof raw.condition === "string" ? raw.condition.trim() : "";
     if (objective.length === 0)
         return undefined;
-    const status = providerGoalStatus(raw.status);
-    if (status === undefined)
-        return undefined;
-    const tokenBudget = positiveOptionalInteger(raw.token_budget ?? raw.tokenBudget);
     return Object.freeze({
         conversationId,
-        status,
+        // Claude emits a live goal or clears it. There is no Codex-style Goal
+        // status/budget/Turn field on this event, and clearing is not success.
+        status: "active",
         objective,
-        updatedAt: providerTimestamp(raw.updated_at ?? raw.updatedAt),
-        ...(optionalId(raw.turn_id ?? raw.turnId) === undefined
-            ? {}
-            : { nativeTurnId: optionalId(raw.turn_id ?? raw.turnId) }),
-        ...(tokenBudget === undefined ? {} : { tokenBudget })
+        // set_at is creation time, not a last-update timestamp.
+        updatedAt: new Date().toISOString()
     });
 }
-function providerGoalStatus(value) {
-    switch (value) {
-        case "active":
-        case "paused":
-        case "blocked":
-        case "complete":
-            return value;
-        case "usageLimited":
-        case "usage_limited":
-        case "usage-limited":
-            return "usage-limited";
-        case "budgetLimited":
-        case "budget_limited":
-        case "budget-limited":
-            return "budget-limited";
-        default:
-            return undefined;
-    }
-}
-function providerTimestamp(value) {
-    if (typeof value === "string" && Number.isFinite(Date.parse(value))) {
-        return new Date(value).toISOString();
-    }
-    if (Number.isSafeInteger(value) && value >= 0) {
-        const epoch = value;
-        return new Date(epoch < 1_000_000_000_000 ? epoch * 1_000 : epoch).toISOString();
-    }
-    return new Date().toISOString();
-}
-function positiveOptionalInteger(value) {
-    return Number.isSafeInteger(value) && value > 0 ? value : undefined;
-}
 function childExit(child, processInstanceId) {
     return new Promise((resolvePromise, reject) => {
         child.once("error", reject);
@@ -971,10 +998,8 @@ function object(value) {
         : null;
 }
 function optionalId(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function nestedId(value, key) {
-    return optionalId(object(value[key])?.id);
+    return typeof value === "string" && !value.includes("\0") && value.length > 0
+        && value.trim() === value ? value : undefined;
 }
 function providerErrorEvidence(value) {
     const error = object(value);

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { serializeRunInputEnvelope } from "../context/runInputContract.js";
+import { readRunContextSnapshot } from "../context/runContextPack.js";
 import { roleSessionMayContinue, sameEffectiveLaunch } from "../executor/effectiveLaunch.js";
 import { RuntimeLifecycleBusyError } from "../runtime/lifecycleReservation.js";
 import { managedProviderTurnId } from "../runtime/providerRuntimeIdentity.js";
@@ -121,6 +122,9 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
     let prepared;
     let submitted = false;
     try {
+        // Validate the dispatch contract before starting any Provider resources.
+        readRunContextSnapshot(store, run);
+        const text = serializeRunInputEnvelope(runInputEnvelope(run));
         const nativeSessionId = mode === "resume"
             ? requireResumeSession(role, run, existingSession)
             : undefined;
@@ -172,7 +176,7 @@ async function deliverActiveRun(store, delivery, task, role, run, now) {
         const outcome = await delivery.sendOnce({
             delivery: ready,
             receiptId: attemptId,
-            text: serializeRunInputEnvelope(runInputEnvelope(run))
+            text
         });
         if (outcome.status === "pending") {
             // The original Host request is still in flight. Its durable submitting

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -1,6 +1,6 @@
 import { createOperatorBatchPresentation } from "../interaction/operatorPresentation.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
-export async function processOperatorInputNotifications(store, delivery, selection, now = new Date()) {
+export async function processOperatorInputNotifications(store, selection, now = new Date()) {
     if (selection !== undefined && !selection.full && !selection.operator)
         return [];
     const targetMailbox = { kind: "operator" };
@@ -35,30 +35,20 @@ export async function processOperatorInputNotifications(store, delivery, selecti
         store.completeWorkMailbox(targetMailbox, processing.batchId);
         return [];
     }
-    const target = store.getOperatorDeliveryTarget();
-    if (target === null || delivery.notifyOperatorInputOnce === undefined) {
-        const reason = target === null ? "operator-unavailable" : "delivery-unsupported";
-        store.releaseWorkMailbox(targetMailbox, processing.batchId);
-        return attentions.map((attention) => skipped(attention, reason));
-    }
     try {
         const presentation = createOperatorBatchPresentation(processing.batchId, attentions.map(toPresentationItem));
-        const outcome = await delivery.notifyOperatorInputOnce({
-            ...target,
+        const outcome = store.queueOperatorNotification({
+            batchId: processing.batchId,
             receiptId: presentation.receiptId,
             text: presentation.text
-        });
-        if (outcome === "unavailable" || outcome === "not-ready") {
+        }, now);
+        if (outcome.status === "unavailable") {
             store.releaseWorkMailbox(targetMailbox, processing.batchId);
-            const reason = outcome === "unavailable" ? "operator-unavailable" : "operator-not-ready";
-            return attentions.map((attention) => skipped(attention, reason));
+            return attentions.map((attention) => skipped(attention, "operator-unavailable"));
         }
-        if (outcome === "sent")
-            store.markOperatorRunStarted(now);
-        store.completeWorkMailbox(targetMailbox, processing.batchId);
         return attentions.map((attention) => ({
             ...attentionIdentity(attention),
-            status: outcome
+            ...outcome
         }));
     }
     catch (error) {

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -1,7 +1,6 @@
 import { join } from "node:path";
 import { copyFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
 import Database from "better-sqlite3";
-import { inspectAgentHostCompatibility, describeAgentHostUpgradeBlockers } from "../../runtime/agentHostCompatibility.js";
 import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation } from "../../runtime/runtimeObservation.js";
 import { RUNTIME_PROCESS_EXIT_TASK_EVENT, validateRuntimeProcessExitObservation } from "../../runtime/processExitObservation.js";
 import { SqliteTaskStore } from "../sqliteStore.js";
@@ -40,15 +39,6 @@ export async function runStorageUpgrade(options) {
             ? classification.classification.blocker.action
             : "Use a compatible Yui release.");
     }
-    const incompatibleHosts = await inspectAgentHostCompatibility(options.home);
-    if (incompatibleHosts.length > 0) {
-        return {
-            ...blocked(state.status === "current" ? currentClassification() : migratableClassification(state.currentVersion), "host-compatibility", `Existing Agent Hosts cannot safely use the target Controller/storage:\n${describeAgentHostUpgradeBlockers(incompatibleHosts)}`, "Keep the current Controller, Home and Host processes unchanged. Inspect the named Sessions and original pending "
-                + "inputs/results; let current work settle, then use explicitly authorized Session replacement/cleanup at a safe "
-                + "boundary before retrying the upgrade. This target cannot hot-patch legacy Host memory."),
-            hosts: incompatibleHosts
-        };
-    }
     if (state.status === "current") {
         try {
             validateCurrentStore(options.home);

package/dist/task/nextAction.js

@@ -91,24 +91,7 @@ export function projectNextAction(facts) {
                         ref: refs[1]
                     }
                 ],
-                recommendedCommand: `yui task work edit ${task.id}/${dependencyIssue.workItemId} --clear-dependencies`
-            });
-        }
-        const draftWork = selectOpenWorkItem(facts.workItems);
-        if (draftWork.kind === "blocked") {
-            const refs = [
-                ref("work-item", draftWork.itemId),
-                ref("work-item", draftWork.blockedBy)
-            ];
-            return buildAction(facts, {
-                kind: "repair-protocol-inconsistency",
-                reason: `Draft Work Item ${draftWork.itemId} depends on ${draftWork.blockedBy}, which is missing, retired, or not completed. Edit the Draft before activation.`,
-                refs,
-                conflicts: refs,
-                preconditions: [
-                    { fact: `Draft dependency ${draftWork.blockedBy} is valid`, satisfied: false, ref: refs[1] }
-                ],
-                recommendedCommand: `yui task work edit ${task.id}/${draftWork.itemId} --clear-dependencies`
+                ...dependencyJudgment(task.id, dependencyIssue.workItemId)
             });
         }
         return buildAction(facts, {
@@ -323,18 +306,24 @@ export function projectNextAction(facts) {
     }
     const openWork = selectOpenWorkItem(facts.workItems);
     if (openWork?.kind === "blocked") {
+        const issue = draftWorkItemDependencyIssue(facts.workItems);
+        const itemId = issue?.workItemId ?? openWork.itemId;
+        const dependencyId = issue?.dependencyId ?? openWork.blockedBy;
         const refs = [
-            ref("work-item", openWork.itemId),
-            ref("work-item", openWork.blockedBy)
+            ref("work-item", itemId),
+            ref("work-item", dependencyId)
         ];
         return buildAction(facts, {
             kind: "repair-protocol-inconsistency",
-            reason: `Work Item ${openWork.itemId} depends on ${openWork.blockedBy}, which is not completed or available.`,
+            reason: issue?.kind === "cycle"
+                ? `Work Item dependency cycle includes ${itemId}/${dependencyId}.`
+                : `Work Item ${itemId} depends on ${dependencyId}, which is ${issue === undefined ? "not completed" : "missing or retired"}.`,
             refs,
             conflicts: refs,
             preconditions: [
-                { fact: `Dependency ${openWork.blockedBy} is completed`, satisfied: false, ref: refs[1] }
-            ]
+                { fact: `Dependency ${dependencyId} is valid and completed`, satisfied: false, ref: refs[1] }
+            ],
+            ...dependencyJudgment(task.id, itemId)
         });
     }
     if (openWork?.kind === "ready") {
@@ -769,6 +758,27 @@ function reviewRoundConflict(round, activeRuns) {
     }
     return null;
 }
+function dependencyJudgment(taskId, workItemId) {
+    return {
+        recommendedCommand: `yui task work show ${taskId}/${workItemId}`,
+        alternatives: [
+            {
+                kind: "inspect-dependencies",
+                reason: "Read the related requirements and dependency records before choosing a repair.",
+                recommendedCommand: `yui task work list ${taskId}`
+            },
+            {
+                kind: "revise-dependencies",
+                reason: "If the intended dependency graph is wrong, edit the affected WorkItem with --after for the complete intended set, preserving unrelated valid dependencies."
+            },
+            {
+                kind: "retire-obsolete-work",
+                reason: "Only if the requirement is no longer needed, deliberately retire it and reconcile its dependents."
+            }
+        ],
+        judgmentRequired: "The records identify a blocked dependency, not which business requirement or edge is wrong. Determine the intended graph from Task requirements; do not infer permission to delete dependencies."
+    };
+}
 function selectOpenWorkItem(workItems) {
     const byId = new Map(workItems.map((item) => [item.id, item]));
     const openItems = workItems.filter((item) => OPEN_WORK_ITEM_STATUSES.has(item.status));

package/dist/task/task.js

@@ -304,7 +304,8 @@ export function reopenTask(task, now) {
             }
             : {}),
         status: "active",
-        executionGate: { state: "enabled" },
+        // Reopening intent does not lift an independent execution stop. Only the
+        // explicit start operation may do that after its authority/cleanup checks.
         updatedAt: now.toISOString()
     });
 }

package/dist/web/assets/assetManifest.js

@@ -9,6 +9,7 @@ import { MARKDOWN_SCRIPT } from "./client/markdown.js";
 import { THEME_SCRIPT } from "./client/theme.js";
 import { VIEW_SCRIPT } from "./client/view.js";
 import { TASK_SURFACE_SCRIPT } from "./client/taskSurface.js";
+import { TASK_SUMMARY_SCRIPT } from "./client/taskSummary.js";
 import { DASHBOARD_HTML } from "./shell.js";
 import { FONT_FACE_STYLES } from "./fonts.js";
 import { FONT_WOFF2_BASE64 } from "./fontData.js";
@@ -35,6 +36,7 @@ export const WEB_ASSETS = Object.freeze({
     "/assets/js/components.js": { contentType: "text/javascript; charset=utf-8", body: COMPONENTS_SCRIPT },
     "/assets/js/view.js": { contentType: "text/javascript; charset=utf-8", body: VIEW_SCRIPT },
     "/assets/js/task-surface.js": { contentType: "text/javascript; charset=utf-8", body: TASK_SURFACE_SCRIPT },
+    "/assets/js/task-summary.js": { contentType: "text/javascript; charset=utf-8", body: TASK_SUMMARY_SCRIPT },
     "/assets/app.js": { contentType: "text/javascript; charset=utf-8", body: APP_SCRIPT },
     ...fontAssets(),
     "/assets/vendor/xterm.mjs": vendorAsset("@xterm/xterm/lib/xterm.mjs", "text/javascript; charset=utf-8"),