@zq-silk/yui 0.15.7 → 0.15.8

package/dist/web/controllerWeb.js

@@ -0,0 +1,60 @@
+import { parseWebCommandOptions, startYuiWebServer } from "./webServer.js";
+/** HTTP listener ownership only, alongside the Controller's one Kernel Host.
+ * The authenticated Controller control socket starts/stops the exact listener;
+ * no capability identity is accepted through this lifecycle API. */
+export function createControllerWeb(store, dependencies) {
+    let current;
+    let starting = false;
+    const close = async () => {
+        const owned = current;
+        if (!owned)
+            return;
+        current = undefined;
+        owned.server.closeTerminals();
+        await new Promise((resolve, reject) => {
+            owned.server.close((error) => error ? reject(error) : resolve());
+            owned.server.closeAllConnections();
+        });
+    };
+    return {
+        close,
+        async dispatch(method, value) {
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                throw new Error("Invalid Web listener request.");
+            const params = value;
+            if (method === "web.status") {
+                if (Object.keys(params).length)
+                    throw new Error("Web status takes no arguments.");
+                return current ? { id: current.id, url: current.url } : null;
+            }
+            if (method === "web.stop") {
+                if (Object.keys(params).some((key) => key !== "id") || typeof params.id !== "string")
+                    throw new Error("Expected Web listener id.");
+                if (!current)
+                    return { stopped: false };
+                if (current.id !== params.id)
+                    throw new Error("Web listener identity changed.");
+                await close();
+                return { stopped: true };
+            }
+            if (method !== "web.start" || Object.keys(params).some((key) => !["id", "host", "port"].includes(key))
+                || typeof params.id !== "string" || !params.id.trim()
+                || typeof params.host !== "string" || typeof params.port !== "number") {
+                throw new Error("Expected id, host and port for Web start.");
+            }
+            const options = parseWebCommandOptions(["--host", params.host, "--port", String(params.port)]);
+            if (starting || current)
+                throw new Error("A Web listener is already starting or running in this Controller.");
+            starting = true;
+            try {
+                const server = await startYuiWebServer(store, options, dependencies);
+                const url = `http://${options.host === "::1" ? "[::1]" : options.host}:${options.port}`;
+                current = { id: params.id, server, url };
+                return { id: params.id, url };
+            }
+            finally {
+                starting = false;
+            }
+        }
+    };
+}

package/dist/web/webMutation.js

@@ -0,0 +1,28 @@
+export class WebRequestRejected extends Error {
+    disposition = "not-submitted";
+}
+/** For Store-only mutations with notifications excluded: an exception from
+ * the callback, propagated unchanged after rollback, proves non-submission.
+ * Commit/rollback failures and post-commit notifications remain unknown. */
+export function webLocalMutation(store, apply) {
+    let rejected = false;
+    let callbackError;
+    try {
+        return store.transaction((tx) => {
+            try {
+                return apply(tx);
+            }
+            catch (error) {
+                rejected = true;
+                callbackError = error;
+                throw error;
+            }
+        });
+    }
+    catch (error) {
+        if (rejected && error === callbackError) {
+            throw new WebRequestRejected(error instanceof Error ? error.message : "Mutation rejected.");
+        }
+        throw error;
+    }
+}

package/dist/web/webServer.js

@@ -2,6 +2,7 @@ import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
 import { usageError } from "../errors/cliError.js";
+import { WebRequestRejected } from "./webMutation.js";
 import { DASHBOARD_HTML, findWebAsset } from "./assets/assetManifest.js";
 import { buildWebDashboardSnapshot, buildWebTaskDetail } from "./webSnapshot.js";
 const MAX_JSON_BODY_BYTES = 16 * 1024;
@@ -53,12 +54,17 @@ export function createYuiWebServer(store, dependencies = {}) {
     server.on("upgrade", (request, socket, head) => {
         void handleTerminalUpgrade(request, socket, head, webSocketServer, dependencies.terminal, token);
     });
-    server.on("close", () => {
+    let terminalsClosed = false;
+    const closeTerminals = () => {
+        if (terminalsClosed)
+            return;
+        terminalsClosed = true;
         for (const socket of webSocketServer.clients)
             socket.terminate();
         webSocketServer.close();
-    });
-    return server;
+    };
+    server.on("close", closeTerminals);
+    return Object.assign(server, { closeTerminals });
 }
 export async function startYuiWebServer(store, options, dependencies = {}) {
     const server = createYuiWebServer(store, dependencies);
@@ -75,7 +81,7 @@ async function handleHttpRequest(request, response, store, dependencies, token,
     setSecurityHeaders(response);
     const method = request.method ?? "GET";
     if (!isLoopbackHost(headerValue(request, "host"))) {
-        sendJson(response, 403, { error: "Invalid Host." }, method === "HEAD");
+        sendJson(response, 403, { error: "Invalid Host.", disposition: "not-submitted" }, method === "HEAD");
         return;
     }
     let pathname;
@@ -83,7 +89,102 @@ async function handleHttpRequest(request, response, store, dependencies, token,
         pathname = new URL(request.url ?? "/", "http://localhost").pathname;
     }
     catch {
-        sendJson(response, 400, { error: "Invalid URL." }, method === "HEAD");
+        sendJson(response, 400, { error: "Invalid URL.", disposition: "not-submitted" }, method === "HEAD");
+        return;
+    }
+    // The loopback page token is the actual user ingress. A request body cannot
+    // select Operator/Leader authority; all API reads use this boundary too.
+    if (pathname.startsWith("/api/") && !tokenMatches(headerValue(request, "x-yui-web-token"), token)) {
+        sendJson(response, 403, { error: "Invalid Yui web token.", disposition: "not-submitted" }, method === "HEAD");
+        return;
+    }
+    const panelTarget = /^\/api\/tasks\/([^/]+)\/panels$/.exec(pathname);
+    if (panelTarget && dependencies.panels) {
+        try {
+            const taskId = decodeURIComponent(panelTarget[1]);
+            if (method === "GET") {
+                sendJson(response, 200, { panels: dependencies.panels.list(taskId), observedAt: now().toISOString() }, false);
+            }
+            else if (method === "POST") {
+                const body = await readMutationBody(request);
+                if (!body || typeof body !== "object" || Array.isArray(body)
+                    || Object.keys(body).some((key) => !["ref", "input"].includes(key))
+                    || !("ref" in body) || !("input" in body))
+                    throw new WebRequestRejected("Expected panel ref and input.");
+                const ref = body.ref;
+                if (!ref || typeof ref !== "object" || typeof ref.capability !== "string"
+                    || typeof ref.contractVersion !== "string" || !ref.provider
+                    || typeof ref.provider.id !== "string" || typeof ref.provider.generation !== "string") {
+                    throw new WebRequestRejected("Invalid panel reference.");
+                }
+                const result = await dependencies.panels.read(taskId, ref, body.input);
+                sendJson(response, 200, { result, observedAt: now().toISOString() }, false);
+            }
+            else
+                sendJson(response, 405, { error: "Method not allowed.", disposition: "not-submitted" }, false);
+        }
+        catch (error) {
+            sendJson(response, 409, { error: error instanceof Error ? error.message : "Panel unavailable.",
+                disposition: "not-submitted" }, false);
+        }
+        return;
+    }
+    const surfaceTarget = /^\/api\/tasks\/([^/]+)\/(context|delta|inspect|metadata|messages)$/.exec(pathname);
+    if (surfaceTarget && dependencies.surface) {
+        try {
+            let taskId;
+            try {
+                taskId = decodeURIComponent(surfaceTarget[1]);
+            }
+            catch {
+                throw new WebRequestRejected("Invalid Task URL encoding.");
+            }
+            const action = surfaceTarget[2];
+            const query = new URL(request.url, "http://localhost").searchParams;
+            let value;
+            if (method === "GET" && action === "context") {
+                value = await dependencies.surface.read(taskId);
+            }
+            else if (method === "GET" && action === "delta") {
+                value = dependencies.surface.delta(taskId, {
+                    after: query.get("after") ?? "",
+                    ...(query.has("continuation") ? { continuation: query.get("continuation") } : {})
+                });
+            }
+            else if (method === "GET" && action === "inspect") {
+                value = dependencies.surface.inspect(taskId, {
+                    store: query.get("store") ?? "", refId: query.get("ref") ?? "",
+                    ...(query.has("digest") ? { digest: query.get("digest") } : {})
+                });
+            }
+            else if (method === "POST" && action === "messages") {
+                const body = await readMutationBody(request);
+                if (typeof body !== "object" || body === null || Array.isArray(body)
+                    || Object.keys(body).some((key) => !["body", "requestId"].includes(key))
+                    || !("requestId" in body) || typeof body.requestId !== "string" || !body.requestId.trim()
+                    || !("body" in body) || typeof body.body !== "string")
+                    throw new WebRequestRejected("Expected body and requestId only.");
+                value = { ...dependencies.surface.message(taskId, body.body), requestId: body.requestId };
+            }
+            else if (method === "POST" && action === "metadata") {
+                const body = await readMutationBody(request);
+                if (typeof body !== "object" || body === null || Array.isArray(body)
+                    || Object.keys(body).some((key) => !["patch", "requestId"].includes(key))
+                    || !("requestId" in body) || typeof body.requestId !== "string" || !body.requestId.trim()
+                    || !("patch" in body))
+                    throw new WebRequestRejected("Expected patch and requestId only.");
+                value = { ...dependencies.surface.update(taskId, body.patch), requestId: body.requestId };
+            }
+            else {
+                sendJson(response, 405, { error: "Method not allowed.", disposition: "not-submitted" }, false);
+                return;
+            }
+            sendJson(response, 200, value, false);
+        }
+        catch (error) {
+            sendJson(response, 409, { error: error instanceof Error ? error.message : "Surface unavailable.",
+                disposition: error instanceof WebRequestRejected ? "not-submitted" : "unknown" }, false);
+        }
         return;
     }
     if (method === "GET" || method === "HEAD") {
@@ -130,7 +231,7 @@ async function handleHttpRequest(request, response, store, dependencies, token,
         }
         catch (error) {
             sendJson(response, 400, {
-                error: error instanceof Error ? error.message : "Invalid input answer."
+                error: error instanceof Error ? error.message : "Invalid input answer.", disposition: "not-submitted"
             }, false);
             return;
         }
@@ -143,13 +244,14 @@ async function handleHttpRequest(request, response, store, dependencies, token,
         }
         catch (error) {
             sendJson(response, 409, {
-                error: error instanceof Error ? error.message : "Unable to answer input request."
+                error: error instanceof Error ? error.message : "Unable to answer input request.",
+                disposition: error instanceof WebRequestRejected ? "not-submitted" : "unknown"
             }, false);
         }
         return;
     }
     response.setHeader("allow", "GET, HEAD");
-    sendJson(response, 405, { error: "Method not allowed." }, method === "HEAD");
+    sendJson(response, 405, { error: "Method not allowed.", disposition: "not-submitted" }, method === "HEAD");
 }
 async function handleTerminalUpgrade(request, socket, head, webSocketServer, terminalPort, token) {
     try {
@@ -340,6 +442,14 @@ function parseWebInputAnswer(value) {
     }
     throw new Error("Exactly one non-empty choiceKey or text is required.");
 }
+async function readMutationBody(request) {
+    try {
+        return await readJsonBody(request);
+    }
+    catch (error) {
+        throw new WebRequestRejected(error instanceof Error ? error.message : "Invalid request body.");
+    }
+}
 async function readJsonBody(request) {
     const chunks = [];
     let size = 0;

package/dist/web/webSnapshot.js

@@ -1,10 +1,11 @@
-import { isRoleTurnStalled, latestTurnDurableProgressAt } from "../scheduler/roleTurnStall.js";
+import { isRoleRunStalled, latestRunDurableProgressAt } from "../scheduler/roleRunStall.js";
 import { retiredTaskRecordIds } from "../task/taskRecordRetirement.js";
 import { buildTaskExecutionProjection } from "../scheduler/taskExecutionProjection.js";
 import { projectWorkItemExecution } from "../execution/workItemExecutionProjection.js";
 import { classifyRuntimeHealth, projectRuntimeTaskEvents } from "../runtime/runtimeProjection.js";
 import { builtinDriverIdForAdapter } from "../runtime/builtinAgentDrivers.js";
-import { formatTurnReceiptId } from "../task/taskRecordReference.js";
+import { formatRunReceiptId } from "../task/taskRecordReference.js";
+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";
@@ -14,7 +15,7 @@ export function buildWebDashboardSnapshot(store, now = new Date()) {
             draft: 0,
             active: 0,
             completed: 0,
-            retired: 0,
+            cancelled: 0,
             archived: 0
         };
         const projectNames = new Map(reader.listProjects().map((project) => [project.id, project.name]));
@@ -31,8 +32,8 @@ export function buildWebDashboardSnapshot(store, now = new Date()) {
                 attention.push({ taskId: task.id, taskTitle: task.title, request });
             }
             const events = reader.listEvents?.(task.id) ?? [];
-            const needsAttentionCount = reader.listTurns(task.id)
-                .filter((turn) => turn.status === "active" && isRoleTurnStalled(events, turn.id))
+            const needsAttentionCount = 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 }) => {
@@ -69,41 +70,51 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
             const name = projectNamesById.get(projectId);
             return name === undefined ? [] : [name];
         });
-        const turns = reader.listTurns(taskId);
+        const runs = reader.listRuns(taskId);
         const events = reader.listEvents?.(taskId) ?? [];
         const retiredMessageIds = retiredTaskRecordIds(events, "message");
-        const needsAttentionTurns = turns
-            .filter((turn) => turn.status === "active" && isRoleTurnStalled(events, turn.id))
-            .map((turn) => ({
-            turnId: turn.id,
-            roleName: turn.roleName,
-            progressAt: latestStallProgress(events, turn.id),
-            kind: latestStallField(events, turn.id, "kind") ?? "workflow-not-progressing",
-            classification: latestStallField(events, turn.id, "classification") ?? "truly-stalled"
+        const needsAttentionRuns = runs
+            .filter((run) => run.status === "active" && isRoleRunStalled(events, run.id))
+            .map((run) => ({
+            runId: run.id,
+            roleName: run.roleName,
+            progressAt: latestStallProgress(events, run.id),
+            kind: latestStallField(events, run.id, "kind") ?? "workflow-not-progressing",
+            classification: latestStallField(events, run.id, "classification") ?? "truly-stalled"
         }));
-        const activeTurns = new Map(turns
-            .filter((turn) => turn.status === "active")
-            .map((turn) => [turn.roleName, turn]));
-        const activeTurnHealth = turns
-            .filter((turn) => turn.status === "active")
-            .map((turn) => projectWebTurnRuntimeHealth(reader, taskId, turn, events, now, resolveRuntimeHealth(reader.getConfig().runtimeHealth)));
+        const activeRuns = new Map(runs
+            .filter((run) => run.status === "active")
+            .map((run) => [run.roleName, run]));
+        const activeRunHealth = runs
+            .filter((run) => run.status === "active")
+            .map((run) => projectWebRunRuntimeHealth(reader, taskId, run, events, now, resolveRuntimeHealth(reader.getConfig().runtimeHealth)));
         const roles = reader.listRoles(taskId).map((role) => {
-            const activeTurn = activeTurns.get(role.name);
+            const activeRun = activeRuns.get(role.name);
             const sessions = reader.getTaskRoleSessionSet(taskId, role.name);
-            const activeSession = sessions?.sessions[sessions.activeAgentId];
-            const effectiveLaunch = activeTurn?.effective ?? activeSession?.effective ?? null;
+            const activeSession = sessions?.sessions[activeRun?.effective.agentId ?? sessions.activeAgentId];
+            const effectiveLaunch = activeRun?.effective ?? activeSession?.effective ?? null;
+            const delivery = sessions?.providerBinding?.run?.status;
             return {
                 ...role,
-                // Presentation only: workflow activity is derived from Turn; the
-                // native Session contributes lifecycle detail when no Turn is active.
-                status: activeTurn === undefined ? activeSession?.status ?? "idle" : "running",
+                // 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",
                 sessionTokens: projectSessionTokenMetrics(events, resolveSessionTokenIdentity(activeSession === undefined
                     ? null
                     : { taskId, roleName: role.name, ...activeSession })),
                 effectiveLaunch,
-                effectiveLaunchSource: activeTurn === undefined
+                observedAt: now.toISOString(),
+                runtimeSession: activeSession === undefined ? null : {
+                    agentId: activeSession.agentId,
+                    adapterId: activeSession.adapterId,
+                    nativeSessionId: activeSession.nativeSessionId ?? null,
+                    status: activeSession.status,
+                    endpointImplementation: activeSession.endpointImplementation ?? null
+                },
+                effectiveLaunchSource: activeRun === undefined
                     ? activeSession === undefined ? null : "session"
-                    : "turn",
+                    : "run",
                 launchDrift: effectiveLaunch !== null
                     && effectiveLaunch.sourceDesiredRevision !== role.launchRevision
             };
@@ -128,10 +139,10 @@ export function buildWebTaskDetail(store, taskId, now = new Date()) {
             workItems: workItems.map((item) => ({
                 ...item,
                 observability: workItemObservability.get(item.id),
-                execution: projectWorkItemExecution(item, turns, roleSessionSets)
+                execution: projectWorkItemExecution(item, runs, roleSessionSets, reader)
             })),
-            turns,
-            runtimeHealth: { needsAttentionTurns, activeTurns: activeTurnHealth },
+            runs: runs.map((run) => ({ ...run, execution: runExecutionObservation(run, reader.getTaskRoleSessionSet(taskId, run.roleName)?.providerBinding, events) })),
+            runtimeHealth: { needsAttentionRuns, activeRuns: activeRunHealth },
             reviewRounds: reader.listReviewRounds(taskId),
             openInputs: inputs.filter((request) => request.status === "open"),
             messages: reader.listMessages(taskId).map((message) => ({
@@ -149,69 +160,68 @@ function webRemoteDelivery(reader, task) {
         events: reader.listEvents?.(task.id) ?? [],
         publications: reader.listPublicationReferences(task.id),
         managedWorkspaces: reader.listManagedWorkspaces(task.id),
-        turns: reader.listTurns(task.id),
+        runs: reader.listRuns(task.id),
         currentCandidate: null
     });
 }
-function latestStallProgress(events, turnId) {
-    return latestStallField(events, turnId, "progressAt");
+function latestStallProgress(events, runId) {
+    return latestStallField(events, runId, "progressAt");
 }
 /**
- * Layered runtime health for one active Turn, computed from the same stored
+ * Layered runtime health for one active AgentRun, computed from the same stored
  * observations and durable semantic fold as the CLI status projection. The
  * Web snapshot has no live tmux pane, so host state stays "unknown"; the
  * classifier still surfaces session/turn/operation/observer layers and the
  * scheduler's durable `turn.stalled` episode is surfaced as
  * `stalled-candidate`.
  */
-function projectWebTurnRuntimeHealth(reader, taskId, turn, events, now, policy) {
-    const stalled = isRoleTurnStalled(events, turn.id);
-    const sessions = reader.getTaskRoleSessionSet(taskId, turn.roleName);
-    const session = sessions?.sessions[turn.effective.agentId];
-    const stallReason = "the live active Turn has no durable progress in the configured stall window";
-    if (session?.runtimeGenerationId === undefined) {
+function projectWebRunRuntimeHealth(reader, taskId, run, events, now, policy) {
+    const stalled = isRoleRunStalled(events, run.id);
+    const sessions = reader.getTaskRoleSessionSet(taskId, run.roleName);
+    const session = sessions?.sessions[run.effective.agentId];
+    const stallReason = "the live active AgentRun has no durable progress in the configured stall window";
+    if (session?.nativeSessionId === undefined) {
         return {
-            turnId: turn.id,
-            roleName: turn.roleName,
+            runId: run.id,
+            roleName: run.roleName,
             layer: stalled ? "stalled-candidate" : "awaiting-provider-acceptance",
-            reason: stalled ? stallReason : "the active Turn is awaiting a Provider Session",
+            reason: stalled ? stallReason : "the active AgentRun is awaiting a Provider Session",
             stalled,
-            lastSemanticProgressAt: turn.createdAt
+            lastSemanticProgressAt: run.createdAt
         };
     }
     let driverId;
     try {
-        driverId = builtinDriverIdForAdapter(turn.effective.adapterId);
+        driverId = builtinDriverIdForAdapter(run.effective.adapterId);
     }
     catch {
         return {
-            turnId: turn.id,
-            roleName: turn.roleName,
+            runId: run.id,
+            roleName: run.roleName,
             layer: stalled ? "stalled-candidate" : "runtime-unobservable",
             reason: stalled ? stallReason : "the Agent Driver is not a built-in driver",
             stalled,
-            lastSemanticProgressAt: turn.createdAt
+            lastSemanticProgressAt: run.createdAt
         };
     }
-    const providerTurn = sessions?.providerBinding?.turn;
+    const providerTurn = sessions?.providerBinding?.run;
     const fence = {
         taskId,
-        roleName: turn.roleName,
-        turnId: turn.id,
-        agentId: turn.effective.agentId,
+        roleName: run.roleName,
+        runId: run.id,
+        agentId: run.effective.agentId,
         driverId,
-        runtimeGenerationId: session.runtimeGenerationId,
         nativeSessionId: session.nativeSessionId,
-        nativeTurnId: providerTurn?.turnId === turn.id
-            ? providerTurn.nativeTurnId ?? turn.id
-            : turn.id,
-        receiptId: providerTurn?.turnId === turn.id
+        nativeTurnId: providerTurn?.runId === run.id
+            ? providerTurn.nativeTurnId ?? run.id
+            : run.id,
+        receiptId: providerTurn?.runId === run.id
             ? providerTurn.attemptId
-            : formatTurnReceiptId(taskId, turn.id)
+            : formatRunReceiptId(taskId, run.id)
     };
-    const projection = projectRuntimeTaskEvents(fence, turn.createdAt, events);
+    const projection = projectRuntimeTaskEvents(fence, run.createdAt, events);
     const view = {
-        getTurn: (taskId, turnId) => reader.listTurns(taskId).find((candidate) => candidate.id === turnId) ?? null,
+        getRun: (taskId, runId) => reader.listRuns(taskId).find((candidate) => candidate.id === runId) ?? null,
         listEvents: () => events,
         getWorkItem: (workItemTaskId, workItemId) => reader.listWorkItems(workItemTaskId).find((item) => item.id === workItemId) ?? null,
         listReviewRounds: (taskId) => reader.listReviewRounds(taskId),
@@ -219,8 +229,8 @@ function projectWebTurnRuntimeHealth(reader, taskId, turn, events, now, policy)
         listIntegrationAttempts: (taskId) => reader.listIntegrationAttempts(taskId),
         listInputRequests: (taskId) => reader.listInputRequests(taskId)
     };
-    const semanticProgress = latestTurnDurableProgressAt(view, taskId, turn.roleName, turn.id)
-        ?? { progressAt: turn.createdAt };
+    const semanticProgress = latestRunDurableProgressAt(view, taskId, run.roleName, run.id)
+        ?? { progressAt: run.createdAt };
     const classification = classifyRuntimeHealth({
         projection,
         semanticProgressAt: semanticProgress.progressAt,
@@ -228,8 +238,8 @@ function projectWebTurnRuntimeHealth(reader, taskId, turn, events, now, policy)
         policy
     });
     return {
-        turnId: turn.id,
-        roleName: turn.roleName,
+        runId: run.id,
+        roleName: run.roleName,
         layer: stalled ? "stalled-candidate" : classification.layer,
         reason: stalled ? stallReason : classification.reason,
         stalled,
@@ -239,10 +249,10 @@ function projectWebTurnRuntimeHealth(reader, taskId, turn, events, now, policy)
         lastSemanticProgressAt: classification.lastSemanticProgressAt
     };
 }
-function latestStallField(events, turnId, field) {
+function latestStallField(events, runId, field) {
     const stalled = events
-        .filter((event) => event.type === "turn.stalled"
-        && event.payload.turnId === turnId
+        .filter((event) => event.type === "run.stalled"
+        && event.payload.runId === runId
         && event.payload.status !== "diagnostic-only")
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt))[0];
     return stalled?.payload[field];
@@ -250,11 +260,8 @@ function latestStallField(events, turnId, field) {
 function countWorkItems(items) {
     const counts = {
         total: items.length,
-        pending: 0,
-        running: 0,
-        awaiting_acceptance: 0,
-        completed: 0,
-        failed: 0,
+        open: 0,
+        accepted: 0,
         retired: 0
     };
     const mutable = counts;
@@ -268,7 +275,7 @@ function compareDashboardTasks(left, right) {
         active: 0,
         draft: 1,
         completed: 2,
-        retired: 3,
+        cancelled: 3,
         archived: 4
     };
     return statusOrder[left.status] - statusOrder[right.status]

package/dist/web/webTaskSurface.js

@@ -0,0 +1,64 @@
+import { readTaskContext, readTaskContextDelta, inspectTaskContext, withContextObservations } from "../context/taskContext.js";
+import { BUILTIN_CAPABILITIES } from "../kernel/builtinCapabilities.js";
+import { capabilitySchemaError } from "../kernel/capabilitySchema.js";
+import { updateTaskMetadataCommand, sendTaskMessageCommand } from "../commands/taskCommands.js";
+import { webLocalMutation, WebRequestRejected } from "./webMutation.js";
+import { runTaskInputCommand } from "../commands/taskInputCommands.js";
+/** Installed only by the local-user Web composition root. HTTP authenticates
+ * its token before using this port; input never supplies a caller or Role.
+ * Managed capability RPC keeps its own Session authentication unchanged.
+ */
+export function createWebTaskSurface(store, options = {}, observations = []) {
+    const environment = {};
+    const commandOptions = { ...options, environment, runtime: undefined };
+    // 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);
+    };
+    return {
+        message: (taskId, body) => {
+            // `queuedForLeader` is the fact the shared transaction actually committed,
+            // not a re-derivation from Task status. A Draft queues its Leader exactly
+            // like an active Task (planning is a Leader conversation), so reporting
+            // "saved" here would have understated a wake that really did happen.
+            const { message, task, queuedForLeader } = webLocalMutation(store, (tx) => sendTaskMessageCommand(tx, taskId, body, "leader", commandOptions));
+            notify(taskId, queuedForLeader);
+            return { record: message, revision: message.createdAt,
+                disposition: queuedForLeader ? "queued" : "saved",
+                planning: task.status === "draft",
+                target: { scope: "task", taskId, roleName: "leader" } };
+        },
+        read: async (taskId) => withContextObservations(readTaskContext(store, taskId, environment), observations),
+        delta: (taskId, input) => readTaskContextDelta(store, taskId, input, environment),
+        inspect: (taskId, input) => inspectTaskContext(store, taskId, input, environment),
+        update: (taskId, input) => {
+            const descriptor = BUILTIN_CAPABILITIES.find((entry) => entry.name === "task.update");
+            const error = capabilitySchemaError(descriptor.inputSchema, { taskId, patch: input });
+            if (error)
+                throw new WebRequestRejected(error);
+            const patch = input;
+            const record = webLocalMutation(store, (tx) => updateTaskMetadataCommand(tx, taskId, {
+                ...patch,
+                ...(patch.description === "" ? { description: null } : {}),
+                ...(patch.tags?.length === 0 ? { tags: null } : {})
+            }, commandOptions));
+            notify(taskId);
+            return { record, revision: record.updatedAt };
+        },
+        answer: (taskId, inputId, answer) => {
+            const result = webLocalMutation(store, (tx) => runTaskInputCommand([
+                "answer", inputId, "--task", taskId,
+                ...("choiceKey" in answer ? ["--choice", answer.choiceKey] : ["--text", answer.text])
+            ], tx, commandOptions));
+            const data = result.data;
+            notify(taskId, true);
+            return data.request;
+        }
+    };
+}

package/dist/workItem/dependencyGate.js

@@ -21,7 +21,7 @@ export class WorkItemDependencyGateError extends Error {
 export function assertWorkItemDependenciesCompleted(store, item) {
     const unmetDependencies = item.dependsOn.flatMap((dependencyId) => {
         const dependency = store.getWorkItem(item.taskId, dependencyId);
-        if (dependency?.status === "completed")
+        if (dependency?.status === "accepted")
             return [];
         return [{
                 id: dependencyId,