@zq-silk/yui 0.15.12 → 0.16.0

package/dist/verification/verificationGateService.js

@@ -2,9 +2,10 @@ import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { mkdir, open, rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { completeGateArtifact, createGateArtifact, gateArtifactRef, isReusableGateArtifact, parseGateArtifactRef, recordGateArtifactReuse, validateGateArtifact, verifyGateArtifactLogs } from "./gateArtifact.js";
-import { findGateArtifact, importGateArtifactSteps, loadGateArtifact, saveGateArtifact, touchGateArtifact } from "./gateArtifactStore.js";
-import { planL1JobSteps, resolveProjectVerificationPlan, resolveToolchain, selectL1Checks, toolchainDigest, verificationPlanDigest, verificationStepCommand } from "./verificationPlan.js";
+import { jobStepDirectory } from "../job/stepDirectory.js";
+import { completeGateArtifact, createGateArtifact, gateArtifactRef, isReusableGateArtifact, parseGateArtifactRef, verifyGateArtifactLogs } from "./gateArtifact.js";
+import { findGateArtifact, importGateArtifactSteps, loadGateArtifact, saveGateArtifact } from "./gateArtifactStore.js";
+import { resolveProjectVerificationPlan, resolveToolchain, toolchainDigest, verificationPlanDigest } from "./verificationPlan.js";
 /** Resolve a Project's active plan and the runtime toolchain it gates under. */
 export function resolveVerificationGate(project, _environment = process.env) {
     const plan = resolveProjectVerificationPlan(project);
@@ -13,26 +14,22 @@ export function resolveVerificationGate(project, _environment = process.env) {
     const toolchain = resolveToolchain();
     return Object.freeze({
         plan,
-        mode: plan.mode,
         toolchain,
         planDigest: verificationPlanDigest(plan),
         toolchainDigest: toolchainDigest(plan, toolchain)
     });
 }
 export function gateIdentityForCandidate(input) {
-    const boundary = input.level === "L2"
-        ? {
-            targetRef: input.targetRef ?? "master",
-            baseHead: input.baseHead ?? input.commit
-        }
-        : undefined;
+    if (input.level !== "L2" || input.targetRef === undefined || input.baseHead === undefined) {
+        throw new Error("L2 verification requires its exact target ref and base head.");
+    }
     return Object.freeze({
         projectId: input.projectId,
         level: input.level,
         commit: input.commit,
         planDigest: input.gate.planDigest,
         toolchainDigest: input.gate.toolchainDigest,
-        ...(boundary === undefined ? {} : { boundary })
+        boundary: { targetRef: input.targetRef, baseHead: input.baseHead }
     });
 }
 /**
@@ -48,6 +45,17 @@ export async function lookupReusableGateArtifact(store, identity) {
     const verification = verifyGateArtifactLogs(artifact, logs);
     return verification.ok ? artifact : null;
 }
+/** Withdraw prior reusable evidence before execution. An interrupted attempt
+ * remains incomplete, never an excuse to return the previous success. */
+export function beginGateVerification(store, identity, plan, now) {
+    const existing = findGateArtifact(store, identity);
+    const artifact = {
+        ...createGateArtifact(identity, { planId: plan.id, planVersion: plan.version, generator: "yui" }, now),
+        reuseCount: existing?.reuseCount ?? 0
+    };
+    saveGateArtifact(store, artifact, new Map());
+    return artifact;
+}
 /**
  * Record a GateArtifact from a terminal check DurableJob. The job's step
  * logs are copied into the artifact store and bound to their digests, so the
@@ -91,38 +99,17 @@ export async function recordGateArtifactFromStepOutcomes(store, identity, plan,
     return recordGateArtifact(store, identity, plan, steps, succeeded, now);
 }
 async function recordGateArtifact(store, identity, plan, steps, succeeded, now) {
-    const created = createGateArtifact(identity, {
-        planId: plan.id,
-        planVersion: plan.version,
-        generator: "yui"
-    }, now);
+    const created = beginGateVerification(store, identity, plan, now);
     const { steps: importedSteps, logs } = await importGateArtifactSteps(steps);
-    let artifact = completeGateArtifact(created, importedSteps, succeeded ? "succeeded" : "failed", now);
-    // Preserve shadow/reuse counters when re-recording the same identity tuple
-    // (e.g. record mode always re-runs the gate but must not lose the potential
-    // reuse observations from earlier runs).
-    const existing = findGateArtifact(store, identity);
-    if (existing !== null) {
-        if (isReusableGateArtifact(existing) && !succeeded) {
-            // A failed re-run must not downgrade a proven successful artifact.
-            touchGateArtifact(store, existing);
-            return existing;
-        }
-        artifact = validateGateArtifact({
-            ...artifact,
-            potentialReuseCount: existing.potentialReuseCount,
-            reuseCount: existing.reuseCount,
-            createdAt: existing.createdAt
-        });
-    }
+    const artifact = completeGateArtifact(created, importedSteps, succeeded && importedSteps.length > 0 && importedSteps.every(step => step.outcome === "passed")
+        ? "succeeded" : "failed", now);
     saveGateArtifact(store, artifact, logs);
     return artifact;
 }
 const GATE_STEP_TIMEOUT_MS = 30 * 60_000;
 const SIGKILL_GRACE_MS = 2_000;
 /**
- * Run structured gate steps in-process (L1 targeted checks and the jobless
- * L2 fallback). Each step gets its own log file; argv steps run without a
+ * Run structured gate steps in-process. Each step gets its own log file; argv steps run without a
  * shell. This is the local form of the gate; the DurableJob form is the
  * Controller-owned one used by production Integration.
  */
@@ -144,9 +131,9 @@ export async function runGateStepsInProcess(workspace, steps, environment, logsD
         const output = await open(absoluteLogPath, "w", 0o600);
         let timedOut = false;
         let child;
-        const stepCwd = step.cwd ?? cwd;
         const stepEnv = step.env === undefined ? env : { ...env, ...step.env };
         try {
+            const stepCwd = jobStepDirectory(cwd, step.cwd);
             if (step.argv !== undefined) {
                 const [file, ...args] = step.argv;
                 child = spawn(file, args, {
@@ -228,7 +215,7 @@ function sanitizeLogName(name) {
  * environment/registry failure is never recorded as a Candidate test
  * failure; the Integration gate has not started when bootstrap fails.
  */
-export function checkResultsFromGateJob(job, home) {
+export function checkResultsFromGateJob(job, _home) {
     const results = new Map((job.result?.steps ?? []).map((step) => [step.name, step]));
     const checks = [];
     for (const step of job.steps) {
@@ -285,6 +272,10 @@ export function checkResultsFromGateArtifact(artifact, reused = false) {
         outcome: step.outcome,
         ...(step.logPath === undefined ? {} : { logPath: step.logPath })
     }));
+    if (!isReusableGateArtifact(artifact) && !checks.some(check => check.outcome === "failed")) {
+        checks.push({ name: "verification-result", outcome: "failed",
+            details: `Verification is ${artifact.status}/${artifact.outcome}; successful evidence is not established.` });
+    }
     if (reused) {
         checks.push({
             name: gateArtifactRef(artifact.key),
@@ -331,56 +322,6 @@ export async function verifyGateArtifactForReview(store, projectId, key, expecte
     }
     return { ok: true, artifact };
 }
-/**
- * Enforce mode (rollout step 4): reject ad-hoc full-suite shell checks that
- * duplicate the plan's L2 steps for a configured Project. Explicit targeted
- * diagnostic checks (anything that is not an L2 step command) stay allowed.
- */
-export function assertNoAdHocFullSuiteChecks(plan, checkCommands) {
-    const l2Commands = new Set(plan.l2.steps.map((step) => verificationStepCommand(step)));
-    for (const command of checkCommands) {
-        if (l2Commands.has(command)) {
-            throw new Error(`Ad-hoc full-suite check is rejected for plan-enabled Project `
-                + `${plan.id}: use the VerificationPlan L2 gate (or pass a targeted `
-                + `diagnostic command that is not an L2 step): ${command}`);
-        }
-    }
-}
-/**
- * Run an L1 gate for a change: select the affected categories' checks, run
- * them in-process, and record the L1 artifact. Reuse mode returns an existing
- * successful artifact for the same tuple.
- */
-export async function runL1Gate(input) {
-    const identity = gateIdentityForCandidate({
-        projectId: input.projectId,
-        gate: input.gate,
-        level: "L1",
-        commit: input.commit
-    });
-    if (input.gate.mode !== "record") {
-        const existing = await lookupReusableGateArtifact(input.store, identity);
-        if (existing !== null) {
-            const reused = recordGateArtifactReuse(existing, input.now);
-            touchGateArtifact(input.store, reused);
-            return {
-                artifact: reused,
-                reused: true,
-                checks: checkResultsFromGateArtifact(reused, true)
-            };
-        }
-    }
-    const selected = selectL1Checks(input.gate.plan, input.changedPaths);
-    const outcomes = await runGateStepsInProcess(input.workspace, planL1JobSteps(selected), input.environment, input.logsDirectory, input.commit);
-    const succeeded = outcomes.length > 0
-        && outcomes.every((outcome) => outcome.exitCode === 0 && outcome.signal === null && !outcome.timedOut);
-    const artifact = await recordGateArtifactFromStepOutcomes(input.store, identity, input.gate.plan, outcomes, succeeded, input.now);
-    return {
-        artifact,
-        reused: false,
-        checks: checkResultsFromGateArtifact(artifact, false)
-    };
-}
 /** Stable digest of a log file, for ad-hoc evidence binding. */
 export function digestLogContent(content) {
     return createHash("sha256").update(content).digest("hex");

package/dist/verification/verificationPlan.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { requireIdentity, requirePositiveInteger, requireText } from "../domain/validation.js";
 /**
  * Issue 08: the per-Project VerificationPlan contract.
@@ -10,7 +11,7 @@ import { requireIdentity, requirePositiveInteger, requireText } from "../domain/
  * explicit `--check <shell>` path, which is marked unstructured and is not
  * reusable across stages.
  */
-export const VERIFICATION_PLAN_SCHEMA_VERSION = 1;
+export const VERIFICATION_PLAN_SCHEMA_VERSION = 2;
 export const VERIFICATION_PLAN_KIND = "verification-plan";
 /** The reserved knowledge marker that carries a Project's VerificationPlan. */
 export const VERIFICATION_PLAN_KNOWLEDGE_KIND = VERIFICATION_PLAN_KIND;
@@ -22,25 +23,21 @@ export function normalizeVerificationPlan(raw) {
     if (record.kind !== VERIFICATION_PLAN_KIND) {
         throw new Error(`VerificationPlan kind must be "${VERIFICATION_PLAN_KIND}".`);
     }
-    const schemaVersion = record.schemaVersion ?? VERIFICATION_PLAN_SCHEMA_VERSION;
+    const schemaVersion = record.schemaVersion;
     if (schemaVersion !== VERIFICATION_PLAN_SCHEMA_VERSION) {
         throw new Error(`VerificationPlan schemaVersion must be ${VERIFICATION_PLAN_SCHEMA_VERSION}.`);
     }
-    const mode = record.mode ?? "record";
-    if (mode !== "record" && mode !== "reuse" && mode !== "enforce") {
-        throw new Error(`VerificationPlan mode is invalid: ${String(mode)}.`);
-    }
+    if (Object.hasOwn(record, "mode"))
+        throw new Error("VerificationPlan mode is retired; request an explicit rerun on the operation.");
+    if (Object.hasOwn(record, "l1"))
+        throw new Error("VerificationPlan l1 is retired; declare current checks in l2.");
     const plan = {
         schemaVersion: VERIFICATION_PLAN_SCHEMA_VERSION,
         kind: VERIFICATION_PLAN_KIND,
         id: requireIdentity(record.id, "VerificationPlan id"),
         version: requireText(record.version, "VerificationPlan version"),
-        mode,
         toolchain: normalizeToolchain(record.toolchain),
         bootstrap: normalizeSteps(record.bootstrap, "bootstrap"),
-        l1: {
-            categories: normalizeL1Categories(record.l1)
-        },
         l2: {
             steps: normalizeSteps(record.l2?.steps, "l2")
         },
@@ -126,34 +123,6 @@ function normalizeStepEnv(raw, label) {
     }
     return Object.freeze(env);
 }
-function normalizeL1Categories(raw) {
-    if (raw === undefined)
-        return Object.freeze([]);
-    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-        throw new Error("VerificationPlan l1 must be an object.");
-    }
-    const categoriesRaw = raw.categories;
-    if (!Array.isArray(categoriesRaw)) {
-        throw new Error("VerificationPlan l1 categories must be an array.");
-    }
-    const ids = new Set();
-    return Object.freeze(categoriesRaw.map((entry) => {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-            throw new Error("VerificationPlan l1 category must be an object.");
-        }
-        const record = entry;
-        const id = requireIdentity(record.id, "VerificationPlan l1 category id");
-        if (ids.has(id)) {
-            throw new Error(`VerificationPlan l1 category ids must be unique: ${id}.`);
-        }
-        ids.add(id);
-        return Object.freeze({
-            id,
-            paths: normalizedTextList(record.paths, `VerificationPlan l1 category ${id} paths`),
-            checks: normalizeSteps(record.checks, `l1 ${id}`)
-        });
-    }));
-}
 function normalizedTextList(raw, label) {
     if (!Array.isArray(raw)) {
         throw new Error(`${label} must be an array.`);
@@ -169,16 +138,18 @@ function normalizedTextList(raw, label) {
 }
 /**
  * The stable digest of the gate contract. It deliberately excludes the
- * rollout `mode`, retention window, and documentation fields: changing the
- * rollout switch must not invalidate proven gate evidence.
+ * retention window and documentation fields. Execution semantics belong to
+ * the identity so evidence from a prior contract is never silently reused.
  */
 export function verificationPlanDigest(plan) {
     const canonical = canonicalJson({
+        // Old artifacts may have skipped shell commands or run in the wrong cwd.
+        // Keep that history, but never reuse it as proof under corrected semantics.
+        executionContract: "workspace-argv-or-shell/clean-candidate/l2-only/v5",
         id: plan.id,
         version: plan.version,
         toolchain: plan.toolchain,
         bootstrap: plan.bootstrap,
-        l1: plan.l1,
         l2: plan.l2,
         ...(plan.l3 === undefined ? {} : { l3: plan.l3 })
     });
@@ -208,46 +179,30 @@ export function toolchainDigest(plan, toolchain) {
     });
     return createHash("sha256").update(canonical).digest("hex");
 }
-/**
- * Select the L1 checks for a change: every category whose path prefixes match
- * a changed path. A category with no path prefixes matches nothing (it must
- * be selected explicitly by the caller).
- */
-export function selectL1Checks(plan, changedPaths) {
-    const selected = new Map();
-    for (const category of plan.l1.categories) {
-        if (category.paths.length === 0)
-            continue;
-        const matches = changedPaths.some((path) => category.paths.some((prefix) => path === prefix || path.startsWith(`${prefix}/`)));
-        if (!matches)
-            continue;
-        for (const check of category.checks) {
-            if (!selected.has(check.name))
-                selected.set(check.name, check);
-        }
-    }
-    return Object.freeze([...selected.values()]);
-}
 /** Bootstrap steps as DurableJob steps, named `bootstrap-N`. */
-export function planBootstrapJobSteps(plan) {
-    return plan.bootstrap.map((step, index) => toDurableJobStep(step, `bootstrap-${index + 1}`));
+export function planBootstrapJobSteps(plan, workspace) {
+    return plan.bootstrap.map((step, index) => toDurableJobStep(step, `bootstrap-${index + 1}`, workspace));
 }
 /** L2 gate steps as DurableJob steps, named `gate-N`. */
-export function planL2JobSteps(plan) {
-    return plan.l2.steps.map((step, index) => toDurableJobStep(step, `gate-${index + 1}`));
+export function planL2JobSteps(plan, workspace) {
+    return plan.l2.steps.map((step, index) => toDurableJobStep(step, `gate-${index + 1}`, workspace));
 }
-/** L1 steps as DurableJob steps, named `l1-N`. */
-export function planL1JobSteps(steps) {
-    return steps.map((step, index) => toDurableJobStep(step, `l1-${index + 1}`));
-}
-function toDurableJobStep(step, name) {
+function toDurableJobStep(step, name, workspace) {
+    if (!isAbsolute(workspace))
+        throw new Error("Verification workspace must be absolute.");
+    const cwd = step.cwd === undefined ? undefined : resolve(workspace, step.cwd);
+    const nested = cwd === undefined ? "" : relative(workspace, cwd);
+    if (step.cwd !== undefined && (isAbsolute(step.cwd) || nested === ".."
+        || nested.startsWith(`..${sep}`) || isAbsolute(nested))) {
+        throw new Error(`Verification step cwd is outside its workspace: ${step.name}.`);
+    }
     return {
         name,
         // The shell-equivalent command stays as the human-readable fallback and
         // the coverage-matching string; argv is the executable form.
         command: step.shell === true ? step.argv.join(" ") : shellQuote(step.argv),
-        argv: step.argv,
-        ...(step.cwd === undefined ? {} : { cwd: step.cwd }),
+        ...(step.shell === true ? {} : { argv: step.argv }),
+        ...(cwd === undefined ? {} : { cwd }),
         ...(step.env === undefined ? {} : { env: step.env })
     };
 }

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

@@ -504,7 +504,7 @@ async function refreshDashboard(options) {
   }
   const previousInputs = state.counts ? state.counts.openInputs : null;
   try {
-    const query = new URLSearchParams({ view: "compact" });
+    const query = new URLSearchParams();
     if (state.catalogAll) query.set("all", "true");
     if (state.filter !== "all") query.set("status", state.filter);
     if (state.query.trim()) query.set("search", state.query.trim());

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

@@ -527,11 +527,11 @@ function renderSubmissionFacets(container, submission, say) {
   const step = submission.nextStep;
   if (step) {
     const nextText = step.kind === "activate-manually"
-      ? say("Next: activate this Task explicitly (yui task activate " + step.taskId + ").",
-        "下一步：显式激活该 Task（yui task activate " + step.taskId + "）。")
+      ? say("Next: request activation with an explicit environment (yui task activation request " + step.taskId + " --request-id <id> --environment <plan>).",
+        "下一步：明确环境并请求激活（yui task activation request " + step.taskId + " --request-id <id> --environment <plan>）。")
       : step.kind === "start-execution"
-      ? say("Next: start execution first, then activate (" + step.taskId + ").",
-        "下一步：先启动执行，再激活（" + step.taskId + "）。")
+      ? say("Next: start execution first, then request activation (" + step.taskId + ").",
+        "下一步：先启动执行，再请求激活（" + step.taskId + "）。")
       : step.kind === "await-pending-activation"
       ? say("Next: waiting on the pending activation " + step.activationRef + ".",
         "下一步：等待待处理的激活 " + step.activationRef + "。")

package/dist/web/webServer.js

@@ -6,7 +6,7 @@ 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, buildWebTaskCatalog, 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;
@@ -238,11 +238,9 @@ async function handleHttpRequest(request, response, store, dependencies, token,
             }
             else if (pathname === "/api/dashboard") {
                 const query = new URL(request.url, "http://localhost").searchParams;
-                const snapshot = query.has("view")
-                    ? buildWebTaskCatalog(store, parseTaskCatalogOptions([...query].flatMap(([key, value]) => key === "all"
-                        ? (value === "true" ? ["--all"] : ["--invalid-all"])
-                        : [`--${key}`, value])))
-                    : buildWebDashboardSnapshot(store, now());
+                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/")) {

package/dist/web/webSnapshot.js

@@ -14,57 +14,6 @@ import { projectTaskRemoteDelivery } from "../task/remoteDelivery.js";
 export function buildWebTaskCatalog(store, options) {
     return store.transaction(reader => readTaskCatalog(reader, options));
 }
-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 buildWebTaskDetail(store, taskId, now = new Date()) {
     return store.transaction((reader) => {
         const task = reader.getTask(taskId);
@@ -77,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))
@@ -128,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);
@@ -166,7 +115,7 @@ 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),
@@ -267,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.