@zq-silk/yui 0.15.7 → 0.15.9

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, intent, requestId) => {
+            // With no explicit intent the Web surface submits `discuss` like every other
+            // client (§2.5), through the one shared service; the requestId is threaded as
+            // the submission key (§2.3) and the structured feedback is returned verbatim.
+            const { message, task, queuedForLeader, feedback } = webLocalMutation(store, (tx) => sendTaskMessageCommand(tx, taskId, body, undefined, commandOptions, undefined, intent, requestId));
+            notify(taskId, queuedForLeader);
+            return { record: message, revision: message.createdAt,
+                disposition: queuedForLeader ? "queued" : "saved",
+                planning: task.status === "draft",
+                ...(feedback === undefined ? {} : { submission: feedback }),
+                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,