@zq-silk/yui 0.15.11 → 0.16.0

package/dist/web/assets/client/view.js

@@ -66,12 +66,17 @@ export function renderFilters(container, state, t, onFilter) {
     if (!btn) return;
     btn.classList.toggle("is-active", state.filter === status);
     const label = btn.querySelector(".filter-label");
-    if (label) label.textContent = status === "all" ? t("filter.unarchived") : translatedStatus(t, "status", status);
+    if (label) label.textContent = status === "all"
+      ? t(state.catalogAll ? "catalog.all" : "filter.unarchived") : translatedStatus(t, "status", status);
     const count = status === "all"
-      ? (counts.total === undefined ? undefined : counts.total - (counts.archived || 0))
+      ? (counts.total === undefined ? undefined : counts.total - (state.catalogAll ? 0 : counts.archived || 0))
       : counts[status];
     const badge = btn.querySelector(".filter-count");
     if (badge) {
+      if (status === "archived" && state.catalogScope && state.catalogScope.archived === "excluded") {
+        badge.hidden = true;
+        return;
+      }
       if (count !== undefined && count !== null) {
         badge.textContent = String(count);
         badge.hidden = false;
@@ -83,7 +88,7 @@ export function renderFilters(container, state, t, onFilter) {
 }
 
 function taskGroupOf(task, attentionIds) {
-  if (attentionIds.has(task.id)) return "attention";
+  if (attentionIds.has(task.id) || (task.attention && (task.attention.openInputs > 0 || task.attention.unknownOperations > 0))) return "attention";
   if (task.status === "active") return "active";
   if (task.status === "draft") return "draft";
   if (task.status === "cancelled") return "cancelled";
@@ -107,9 +112,9 @@ export function renderTasks(container, state, t, locale, onSelect) {
   const attentionIds = new Set((state.attention || []).map(function (item) { return item.taskId; }));
   const groups = { attention: [], active: [], draft: [], finished: [], cancelled: [], archived: [] };
   (state.tasks || []).forEach(function (task) {
-    if (state.filter === "all" && task.status === "archived") return;
+    if (state.filter === "all" && !state.catalogAll && task.status === "archived") return;
     if (state.filter !== "all" && task.status !== state.filter) return;
-    if (!taskMatchesQuery(task, query, locale)) return;
+    if (!state.catalogScope && !taskMatchesQuery(task, query, locale)) return;
     groups[taskGroupOf(task, attentionIds)].push(task);
   });
 
@@ -166,15 +171,33 @@ export function renderOverview(detail, state, t, locale, onSelect) {
   );
   wrap.append(rail);
 
+  if (state.catalogAttention) {
+    const catalog = node("section", "overview-block");
+    catalog.append(sectionHead(t("catalog.attention")));
+    catalog.append(node("p", "", t("catalog.signalsHelp")));
+    const groups = node("div", "overview-list");
+    Object.entries(state.catalogAttention).forEach(function (entry) {
+      const kind = entry[0], value = entry[1];
+      const button = node("button", "overview-row",
+        t("catalog." + kind) + " · " + value.count + " / " + value.taskCount + " " + t("catalog.tasks"));
+      button.type = "button";
+      button.dataset.catalogAttention = kind;
+      button.disabled = value.taskCount === 0;
+      groups.append(button);
+    });
+    catalog.append(groups);
+    wrap.append(catalog);
+  }
   const inbox = node("section", "overview-block");
   const inboxHead = sectionHead(t("overview.inbox"), {
-    count: (state.attention || []).length
+    count: counts ? counts.openInputs : (state.attention || []).length
   });
   inbox.append(inboxHead);
   const items = state.attention || [];
   if (!items.length) {
     const empty = node("div", "inbox-empty");
-    empty.append(node("span", "dot"), node("span", "", t("overview.inboxEmpty")));
+    empty.append(node("span", "dot"), node("span", "", counts && counts.openInputs > 0
+      ? t("catalog.inspectInputs") : t("overview.inboxEmpty")));
     inbox.append(empty);
   } else {
     const list = node("div", "inbox-list");
@@ -184,6 +207,7 @@ export function renderOverview(detail, state, t, locale, onSelect) {
     inbox.append(list);
   }
   wrap.append(inbox);
+  if (state.catalogScope) wrap.append(node("p", "", t("catalog.pageScope")));
 
   // Tasks whose Task-first projection says they need attention: blocked,
   // recovering, or in an attention state. This replaces the raw stalled-AgentRun
@@ -335,9 +359,13 @@ export function renderTaskDetail(detail, data, t, locale, actions) {
         "muted mono",
         project.directory + " · " + project.coverage + " · "
           + (project.expectedLocalCommit ? project.expectedLocalCommit.slice(0, 12) : "unknown")
+          + " → " + (project.deliveryLocalCommit ? project.deliveryLocalCommit.slice(0, 12) : "unknown")
           + " → "
           + (project.remoteCommit ? project.remoteCommit.slice(0, 12) : "unknown")
+          + " · PR/MR: " + (project.state || "none")
+          + (project.adoption ? " · " + project.adoption.id : "")
       ));
+      card.append(node("p", "record-copy", project.reason));
     });
     summaryBody.append(card);
   }

package/dist/web/assets/shell.js

@@ -38,6 +38,12 @@ export const DASHBOARD_HTML = `<!doctype html>
       </label>
       <div id="status-filters" class="filters" role="group" aria-label="Filter by status" data-i18n-aria-label="filters.label"></div>
       <div id="task-list" class="task-list" aria-label="Tasks" data-i18n-aria-label="board.title" aria-live="polite"><div class="loading" data-i18n="loading.dashboard">Reading local state…</div></div>
+      <div id="catalog-controls" class="catalog-pager" aria-live="polite">
+        <button id="catalog-reset" type="button" data-i18n="catalog.first">First page</button>
+        <span id="catalog-count"></span>
+        <button id="catalog-next" type="button" data-i18n="catalog.next" disabled>Next page</button>
+        <button id="catalog-attention-reset" type="button" data-i18n="catalog.clearAttention" hidden>Clear attention filter</button>
+      </div>
       <div class="sidebar-foot">
         <div class="sidebar-controls">
           <label class="select-control">

package/dist/web/assets/styles/layout.js

@@ -19,6 +19,13 @@ body.terminal-active .app-shell{grid-template-columns:var(--sidebar-w) minmax(0,
 .task-group-head{display:flex;align-items:baseline;gap:8px;padding:3px 4px 2px}
 .sidebar-foot{flex:none;padding-top:10px;margin-top:8px;display:grid;gap:8px}
 .sidebar-controls{display:grid;grid-template-columns:1fr 1fr;gap:8px;align-items:center}
+.catalog-pager{display:grid;grid-template-columns:1fr 1fr;gap:6px;flex:none;padding-top:10px}
+.catalog-pager span{grid-column:1/-1;grid-row:1;text-align:center;font-size:11px;color:var(--muted)}
+.catalog-pager button{min-height:32px;min-width:0;border:1px solid var(--border);border-radius:6px;background:var(--bg);color:var(--text);font:inherit;font-size:11px;cursor:pointer}
+.catalog-pager button:hover:not(:disabled){border-color:var(--accent)}
+.catalog-pager button:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+.catalog-pager button:disabled{opacity:.45;cursor:default}
+#catalog-attention-reset{grid-column:1/-1}
 /* Main column = top bar + optional section nav + reading surface */
 .main-col{display:flex;flex-direction:column;min-width:0;min-height:0;height:100vh;overflow-y:auto;scrollbar-gutter:stable}
 .topbar{position:sticky;top:0;z-index:30;flex:none;display:flex;align-items:center;justify-content:space-between;gap:18px;padding:11px max(var(--page-space),calc((100% - 1100px) / 2));background:color-mix(in srgb,var(--bg) 92%,transparent);backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);border-bottom:1px solid var(--border)}

package/dist/web/webServer.js

@@ -1,11 +1,12 @@
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
-import { usageError } from "../errors/cliError.js";
+import { CliError, usageError } from "../errors/cliError.js";
+import { parseTaskCatalogOptions } from "../context/taskCatalog.js";
 import { WebRequestRejected } from "./webMutation.js";
 import { TASK_SUBMISSION_INTENTS } from "../message/message.js";
 import { DASHBOARD_HTML, findWebAsset } from "./assets/assetManifest.js";
-import { buildWebDashboardSnapshot, buildWebTaskDetail } from "./webSnapshot.js";
+import { buildWebTaskCatalog, buildWebTaskDetail } from "./webSnapshot.js";
 const MAX_JSON_BODY_BYTES = 16 * 1024;
 const MAX_TERMINAL_MESSAGE_BYTES = 64 * 1024;
 const MAX_TERMINAL_BUFFERED_BYTES = 1024 * 1024;
@@ -236,7 +237,11 @@ async function handleHttpRequest(request, response, store, dependencies, token,
                 sendAsset(response, asset, method === "HEAD");
             }
             else if (pathname === "/api/dashboard") {
-                sendJson(response, 200, buildWebDashboardSnapshot(store, now()), method === "HEAD");
+                const query = new URL(request.url, "http://localhost").searchParams;
+                const snapshot = buildWebTaskCatalog(store, parseTaskCatalogOptions([...query].flatMap(([key, value]) => key === "all"
+                    ? (value === "true" ? ["--all"] : ["--invalid-all"])
+                    : [`--${key}`, value])));
+                sendJson(response, 200, snapshot, method === "HEAD");
             }
             else if (pathname.startsWith("/api/tasks/")) {
                 const taskId = decodeURIComponent(pathname.slice("/api/tasks/".length));
@@ -250,6 +255,10 @@ async function handleHttpRequest(request, response, store, dependencies, token,
             }
         }
         catch (error) {
+            if (error instanceof CliError) {
+                sendJson(response, 400, { error: error.message }, method === "HEAD");
+                return;
+            }
             if (error instanceof URIError) {
                 sendJson(response, 400, { error: "Invalid URL encoding." }, method === "HEAD");
                 return;

package/dist/web/webSnapshot.js

@@ -1,3 +1,5 @@
+import { providerRetryProjection } from "../runtime/providerRetry.js";
+import { readTaskCatalog } from "../context/taskCatalog.js";
 import { isRoleRunStalled, latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
@@ -9,56 +11,8 @@ import { runExecutionObservation } from "../agentRun/agentRun.js";
 import { resolveRuntimeHealth } from "../config/yuiConfig.js";
 import { projectSessionTokenMetrics, resolveSessionTokenIdentity } from "../runtime/sessionTokenMetrics.js";
 import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
-export function buildWebDashboardSnapshot(store, now = new Date()) {
-    return store.transaction((reader) => {
-        const statusCounts = {
-            draft: 0,
-            active: 0,
-            completed: 0,
-            cancelled: 0,
-            archived: 0
-        };
-        const projectNames = new Map(reader.listProjects().map((project) => [project.id, project.name]));
-        let openInputs = 0;
-        const attention = [];
-        const tasks = reader.listTasks().map((task) => {
-            statusCounts[task.status] += 1;
-            const taskOpenInputs = reader.listInputRequests(task.id)
-                .filter((request) => request.status === "open").length;
-            if (task.status !== "archived")
-                openInputs += taskOpenInputs;
-            const taskOpen = reader.listInputRequests(task.id)
-                .filter((request) => request.status === "open");
-            for (const request of task.status === "archived" ? [] : taskOpen) {
-                attention.push({ taskId: task.id, taskTitle: task.title, request });
-            }
-            const events = reader.listEvents?.(task.id) ?? [];
-            const needsAttentionCount = task.status === "archived" ? 0 : reader.listRuns(task.id)
-                .filter((run) => run.status === "active" && isRoleRunStalled(events, run.id))
-                .length;
-            const execution = buildTaskExecutionProjection(reader, task.id, task, now);
-            const names = task.projectBindings.flatMap(({ projectId }) => {
-                const name = projectNames.get(projectId);
-                return name === undefined ? [] : [name];
-            });
-            return {
-                ...task,
-                ...(names.length === 0 ? {} : { projectNames: names }),
-                workItems: countWorkItems(reader.listWorkItems(task.id)),
-                roleCount: reader.listRoles(task.id).length,
-                openInputCount: taskOpenInputs,
-                needsAttentionCount,
-                execution,
-                executionStatus: execution?.status ?? null
-            };
-        }).sort(compareDashboardTasks);
-        return {
-            generatedAt: now.toISOString(),
-            counts: { total: tasks.length, ...statusCounts, openInputs },
-            attention: attention.sort(compareAttention),
-            tasks
-        };
-    });
+export function buildWebTaskCatalog(store, options) {
+    return store.transaction(reader => readTaskCatalog(reader, options));
 }
 export function buildWebTaskDetail(store, taskId, now = new Date()) {
     return store.transaction((reader) => {
@@ -72,7 +26,7 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
             return name === undefined ? [] : [name];
         });
         const runs = reader.listRuns(taskId);
-        const events = reader.listEvents?.(taskId) ?? [];
+        const events = reader.listEvents(taskId);
         const retiredMessageIds = retiredTaskRecordIds(events, "message");
         const needsAttentionRuns = runs
             .filter((run) => run.status === "active" && isRoleRunStalled(events, run.id))
@@ -95,12 +49,15 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
             const activeSession = sessions?.sessions[activeRun?.effective.agentId ?? sessions.activeAgentId];
             const effectiveLaunch = activeRun?.effective ?? activeSession?.effective ?? null;
             const delivery = sessions?.providerBinding?.run?.status;
+            const providerRetry = providerRetryProjection(sessions?.providerBinding);
             return {
                 ...role,
+                providerRetry,
                 // An open record is not proof that its Agent is running.
-                status: delivery === "accepted" ? "running"
-                    : delivery === "submitting" || delivery === "deferred" ? "waiting"
-                        : activeSession === undefined && activeRun === undefined ? "idle" : "unknown",
+                status: providerRetry?.status === "waiting" ? "waiting"
+                    : delivery === "accepted" ? "running"
+                        : delivery === "submitting" || delivery === "deferred" ? "waiting"
+                            : activeSession === undefined && activeRun === undefined ? "idle" : "unknown",
                 sessionTokens: projectSessionTokenMetrics(events, resolveSessionTokenIdentity(activeSession === undefined
                     ? null
                     : { taskId, roleName: role.name, ...activeSession })),
@@ -120,7 +77,7 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
                     && effectiveLaunch.sourceDesiredRevision !== role.launchRevision
             };
         });
-        const execution = buildTaskExecutionProjection(reader, taskId, task, now);
+        const execution = buildTaskExecutionProjection(reader, taskId, now);
         if (execution === null)
             return null;
         const remoteDelivery = webRemoteDelivery(reader, task);
@@ -158,10 +115,11 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
 function webRemoteDelivery(reader, task) {
     return projectTaskRemoteDelivery({
         task,
-        events: reader.listEvents?.(task.id) ?? [],
+        events: reader.listEvents(task.id),
         publications: reader.listPublicationReferences(task.id),
         managedWorkspaces: reader.listManagedWorkspaces(task.id),
         runs: reader.listRuns(task.id),
+        integrations: reader.listIntegrationAttempts(task.id),
         currentCandidate: null
     });
 }
@@ -258,32 +216,3 @@ function latestStallField(events, runId, field) {
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return stalled?.payload[field];
 }
-function countWorkItems(items) {
-    const counts = {
-        total: items.length,
-        open: 0,
-        accepted: 0,
-        retired: 0
-    };
-    const mutable = counts;
-    for (const item of items) {
-        mutable[item.status] += 1;
-    }
-    return counts;
-}
-function compareDashboardTasks(left, right) {
-    const statusOrder = {
-        active: 0,
-        draft: 1,
-        completed: 2,
-        cancelled: 3,
-        archived: 4
-    };
-    return statusOrder[left.status] - statusOrder[right.status]
-        || Date.parse(right.updatedAt) - Date.parse(left.updatedAt)
-        || left.id.localeCompare(right.id);
-}
-function compareAttention(left, right) {
-    return Date.parse(left.request.createdAt) - Date.parse(right.request.createdAt)
-        || left.request.id.localeCompare(right.request.id);
-}

package/dist/web/webTaskSurface.js

@@ -1,37 +1,17 @@
-import { recordTaskInterruptResult } from "../message/taskInterrupt.js";
-import { recordGlobalInterruptResult, recordGlobalSteerResult } from "../message/globalInterrupt.js";
-import { runGlobalRoleCommand } from "../commands/globalRoleCommands.js";
-import { readTaskContext, readTaskContextDelta, inspectTaskContext, withContextObservations } from "../context/taskContext.js";
+import { applyGlobalInputControl } from "../commands/globalRoleCommands.js";
+import { applyTaskInputControl, sendTaskMessageCommand, updateTaskMetadataCommand } from "../commands/taskCommands.js";
+import { runTaskInputCommand } from "../commands/taskInputCommands.js";
+import { inspectTaskContext, readTaskContext, readTaskContextDelta, withContextObservations } from "../context/taskContext.js";
 import { BUILTIN_CAPABILITIES } from "../kernel/builtinCapabilities.js";
 import { capabilitySchemaError } from "../kernel/capabilitySchema.js";
-import { updateTaskMetadataCommand, sendTaskMessageCommand, runTaskCommand } from "../commands/taskCommands.js";
+import { recordGlobalInterruptResult, recordGlobalSteerResult } from "../message/globalInterrupt.js";
+import { recordTaskInterruptResult } from "../message/taskInterrupt.js";
+import { AGENT_HOST_CONTROL_PROTOCOL, foldInterruptLiveReceipt, foldSteerLiveReceipt, sendAgentHostCancelControl, sendAgentHostSteerControl } from "../runtime/agentHost.js";
 import { webLocalMutation, WebRequestRejected } from "./webMutation.js";
-import { runTaskInputCommand } from "../commands/taskInputCommands.js";
-import { sendAgentHostSteerControl, sendAgentHostCancelControl, AGENT_HOST_CONTROL_PROTOCOL, foldSteerLiveReceipt, foldInterruptLiveReceipt } from "../runtime/agentHost.js";
 const DEFAULT_WEB_HOST_CONTROL = {
     steer: sendAgentHostSteerControl,
     cancel: sendAgentHostCancelControl
 };
-/** The store-only CLI argv for the shared application-layer primitive
- * (decision-3 §7). The Web surface never re-implements the queue/steer/interrupt
- * decisions; it drives the exact same command the CLI drives. */
-function controlArgv(taskId, input) {
-    if (input.action === "queue") {
-        return ["message", "queue", taskId, input.body, "--request-id", input.requestId,
-            ...(input.to === undefined ? [] : ["--to", input.to]),
-            ...(input.workItem === undefined ? [] : ["--work-item", input.workItem]),
-            ...(input.reviewRound === undefined ? [] : ["--review-round", input.reviewRound])];
-    }
-    if (input.action === "steer") {
-        return ["message", "steer", taskId, input.body, "--request-id", input.requestId,
-            "--expected-target", input.expectedTarget, "--to", input.to,
-            ...(input.workItem === undefined ? [] : ["--work-item", input.workItem]),
-            ...(input.reviewRound === undefined ? [] : ["--review-round", input.reviewRound])];
-    }
-    return ["role", "interrupt", taskId, input.role, "--expected-target", input.expectedTarget,
-        ...(input.thenMessage === undefined ? [] : ["--then-message", input.thenMessage]),
-        "--request-id", input.requestId];
-}
 /** A queue is delivered to the Leader mailbox only when it is unaddressed or
  * addressed to the Leader; an addressed Worker/Reviewer queue goes to the Task
  * mailbox. A steer/interrupt is a live control op, so it only reconciles the
@@ -53,12 +33,8 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
     // Notifications are after the outer transaction. Their failure must not be
     // reclassified as a rejection of a mutation that already committed.
     const notify = (taskId, leader = false) => {
-        if (options.runtime?.notifyMailboxChanged) {
-            void options.runtime.notifyMailboxChanged(leader
-                ? { kind: "role", taskId, roleName: "leader" } : { kind: "task", taskId });
-        }
-        else
-            options.runtime?.notifyStateChanged(taskId);
+        void options.runtime?.notifyMailboxChanged(leader
+            ? { kind: "role", taskId, roleName: "leader" } : { kind: "task", taskId });
     };
     return {
         globalState: (roleName) => {
@@ -79,20 +55,15 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
             };
         },
         globalControl: async (roleName, input) => {
-            const argv = input.action === "interrupt"
-                ? ["interrupt", roleName, "--request-id", input.requestId, "--expected-target", input.expectedTarget,
-                    ...(input.thenMessage === undefined ? [] : ["--then-message", input.thenMessage])]
-                : ["message", input.action, roleName, input.body, "--request-id", input.requestId,
-                    ...(input.action === "steer" ? ["--expected-target", input.expectedTarget] : [])];
-            const result = webLocalMutation(store, tx => runGlobalRoleCommand(argv, tx, {
-                env: {}, yuiHome: options.yuiHome, jsonOutput: true
+            const result = webLocalMutation(store, tx => applyGlobalInputControl(roleName, input, tx, {
+                env: {}, yuiHome: options.yuiHome
             }));
-            if (typeof result === "string") {
+            if (result.kind === "output") {
                 if (input.action === "queue")
-                    void options.runtime?.notifyMailboxChanged?.({
+                    void options.runtime?.notifyMailboxChanged({
                         kind: "global-role-runtime", roleName
                     });
-                return { action: input.action, ...JSON.parse(result) };
+                return { action: input.action, ...result.data };
             }
             if (result.kind !== "input-steer" && result.kind !== "input-interrupt") {
                 throw new WebRequestRejected("Global input cannot perform a Session lifecycle operation.");
@@ -138,7 +109,7 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
         message: (taskId, body, intent, requestId) => {
             // Preserve the submission's intent and frozen receipt separately from
             // queue/steer controls; an omitted intent still means discuss.
-            const { message, task, queuedForLeader, feedback } = webLocalMutation(store, (tx) => sendTaskMessageCommand(tx, taskId, body, undefined, commandOptions, undefined, intent, requestId));
+            const { message, task, queuedForLeader, feedback } = webLocalMutation(store, (tx) => sendTaskMessageCommand(tx, taskId, body, commandOptions, undefined, intent, requestId));
             notify(taskId, queuedForLeader);
             return { record: message, revision: message.createdAt,
                 disposition: queuedForLeader ? "queued" : "saved",
@@ -149,7 +120,7 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
         /**
          * The decision-3 three-action input-control path for the local-user Web
          * surface. Its store-only phase is the identical shared application-layer
-         * primitive the CLI uses (`runTaskCommand`), run inside `webLocalMutation`
+         * typed primitive the CLI uses, run inside `webLocalMutation`
          * so a rejected input is provably not-submitted. A ready steer/interrupt
          * returns a live intent; the single Agent Host edge then runs OUTSIDE the
          * transaction exactly as cli.ts performs it — never a fallback, retarget, or
@@ -158,7 +129,7 @@ export function createWebTaskSurface(store, options = {}, observations = [], hos
          * the durable Message is retained (decision-3 §1/§3/§5, message-5 gap F).
          */
         control: async (taskId, input) => {
-            const execution = webLocalMutation(store, (tx) => runTaskCommand(controlArgv(taskId, input), tx, commandOptions));
+            const execution = webLocalMutation(store, (tx) => applyTaskInputControl(taskId, input, tx, commandOptions));
             if (execution.kind === "output") {
                 // A queue receipt, or a steer/interrupt that was saved-but-not-delivered
                 // or an idempotent replay: fully durable, no live edge, exact disposition.

package/dist/workItem/workItem.js

@@ -319,8 +319,7 @@ export function validateWorkItem(workItem) {
         "updatedAt",
         "endedAt",
         "acceptedCandidateId",
-        "currentCandidateId",
-        "historicalState"
+        "currentCandidateId"
     ], "WorkItem");
     if (workItem.schemaVersion !== 15)
         throw new Error("WorkItem must use schemaVersion 15.");
@@ -397,16 +396,6 @@ export function validateWorkItem(workItem) {
     if (workItem.currentCandidateId !== undefined
         && !candidateIds.has(workItem.currentCandidateId))
         throw new Error("Current Candidate is missing.");
-    if (workItem.historicalState !== undefined) {
-        const historical = workItem.historicalState;
-        if (!["pending", "running", "awaiting_acceptance", "completed", "failed", "retired"].includes(historical.status)) {
-            throw new Error("Historical Work Item status is invalid.");
-        }
-        if (historical.outcome !== undefined)
-            requireText(historical.outcome, "Historical outcome");
-        if (historical.endedAt !== undefined)
-            requireTimestamp(historical.endedAt, "Historical endedAt");
-    }
     if (workItem.outcome !== undefined)
         requireText(workItem.outcome, "Work item outcome");
     requireTimestamp(workItem.createdAt, "Work Item createdAt");

package/dist/workspace/cleanupInspection.js

@@ -0,0 +1,63 @@
+import { isAbsolute, join, relative } from "node:path";
+export class CleanupInspectionError extends Error {
+    checks;
+    constructor(checks) {
+        super(checks.map(renderCleanupCheck).join("\n"));
+        this.checks = checks;
+        this.name = "CleanupInspectionError";
+    }
+}
+export function renderCleanupCheck(check) {
+    return `[${check.reason}] ${check.resource}: ${check.detail}`
+        + ` Expected=${JSON.stringify(check.expected)}; observed=${JSON.stringify(check.observed)}.`
+        + (check.actions.length === 0 ? "" : ` Inspect/resolve: ${check.actions.join("; ")}.`);
+}
+/** Do not forward arbitrary Git stderr, native arguments, or foreign paths. */
+export function cleanupCheckFromError(error, resource, sources, actions) {
+    if (error instanceof CleanupInspectionError) {
+        return error.checks.map(check => ({ ...check, resource, sources, actions }));
+    }
+    let cause = error;
+    let errorCode;
+    for (let depth = 0; depth < 4 && cause instanceof Error; depth += 1) {
+        const code = cause.code;
+        if ((typeof code === "string" && /^[A-Z][A-Z0-9_]{0,63}$/.test(code))
+            || (typeof code === "number" && Number.isSafeInteger(code))) {
+            errorCode = code;
+            break;
+        }
+        cause = cause.cause;
+    }
+    return [{ resource, reason: "inspection-unavailable", status: "unknown",
+            detail: "The resource could not be inspected; no safe cleanup conclusion is available.",
+            expected: "readable owned resource", observed: errorCode === undefined ? "unavailable" : { errorCode }, sources, actions }];
+}
+export function cleanupFailure(reason, detail, expected, observed, status = "blocked") {
+    throw new CleanupInspectionError([{ resource: "git-workspace", reason, status,
+            detail, expected, observed, sources: [], actions: [] }]);
+}
+/** Describe exact differences without disclosing paths outside this Task.
+ * Legacy locations are displayed only for this Task's exact branch identity;
+ * displaying a historical location is not accepting it as migration proof.
+ */
+export function workspacePathValue(workspace, path) {
+    const inside = (root) => {
+        const value = relative(root, path);
+        return value !== ".." && !value.startsWith("../") && !isAbsolute(value) ? value || "." : undefined;
+    };
+    const marker = `/workspaces/tasks/${workspace.owner.taskId}/`;
+    const index = workspace.root.lastIndexOf(marker);
+    if (index >= 0) {
+        const home = workspace.root.slice(0, index);
+        const taskPath = inside(join(home, "workspaces", "tasks", workspace.owner.taskId));
+        if (taskPath !== undefined)
+            return `<task>/${taskPath}`;
+        const legacyPath = inside(join(home, "workspaces", "worktree"));
+        const parts = legacyPath?.split("/");
+        const taskSegment = workspace.entries.find(e => e.access === "write")?.branch.split("/")[1];
+        if (parts?.length === 3 && parts[1] === taskSegment)
+            return `<legacy-worktree>/${legacyPath}`;
+    }
+    const local = inside(workspace.root);
+    return local === undefined ? "[outside authorized Task paths]" : `<owner>/${local}`;
+}