@zq-silk/yui 0.15.8 → 0.15.9

package/dist/task/taskActivationService.js

@@ -40,80 +40,96 @@ export function taskActivationOperationRef(taskId, requestId) {
  * unchanged, so a retried tool call cannot produce a second activation.
  */
 export function requestTaskActivation(store, input, now) {
-    return store.transaction((tx) => {
-        const task = requireOpenDraft(tx, input.taskId);
-        const plan = canonicalEnvironmentPlan(input.environmentPlan);
-        const planningRun = resolveCallerPlanningRun(tx, task.id, input.callerRunId);
-        const startMode = planningRun === undefined
-            ? "immediate"
-            : "after-planning-turn";
-        const existing = task.activationRequest;
-        // A requestId whose outcome was already decided is never re-opened, whether
-        // it still holds the slot or a later request displaced it. Cancelling A,
-        // requesting B and then retrying A must not resurrect A: the withdrawal is
-        // explicit authority, and adoption is exactly the effect it withdrew. An
-        // adopted id is equally final — its environment and status change happened.
-        // Only `failed` stays replayable, which is its documented contract.
-        //
-        // The authority is the durable activation event ledger, not the bounded
-        // display payload: the payload trims its oldest entries once it overflows,
-        // but the terminal events are never compacted, so an evicted cancellation is
-        // still refused with its original outcome instead of silently resurrecting.
-        const settled = settledActivationRequest(tx, task, input.requestId);
-        if (settled !== undefined) {
-            throw new Error(`Activation request ${input.requestId} was already ${settled.disposition} for ${task.id}`
-                + `${settled.outcome === undefined ? "" : ` (${settled.outcome})`}. `
-                + "Use a new requestId.");
-        }
-        if (existing?.operation.requestId === input.requestId) {
-            const digest = taskActivationInputDigest(task.id, {
-                startMode,
-                ...(planningRun === undefined ? {} : { afterPlanningRun: planningRun }),
-                environmentPlan: plan
-            });
-            if (existing.operation.inputDigest !== digest) {
-                throw new Error(`Activation requestId ${input.requestId} was already used for different inputs.`);
-            }
-            return {
-                operationRef: taskActivationOperationRef(task.id, existing.operation.requestId),
-                request: existing,
-                startMode: existing.startMode,
-                created: false,
-                ...(existing.afterPlanningRun === undefined
-                    ? {}
-                    : { afterPlanningRun: existing.afterPlanningRun })
-            };
-        }
-        if (existing?.disposition === "pending") {
-            throw new Error(`Task already has a pending activation request: ${task.id}/${existing.operation.requestId}. `
-                + "Cancel it before requesting different inputs.");
-        }
-        const request = createTaskActivationRequest(task.id, {
-            requestId: input.requestId,
-            actorId: input.actorId,
-            authorityRef: input.authorityRef,
+    return store.transaction((tx) => recordTaskActivationRequestInTransaction(tx, input, now));
+}
+/**
+ * The transactional core of {@link requestTaskActivation}, callable from inside
+ * a caller's own open transaction.
+ *
+ * The shared submission service (task-32 §2.3) records a develop route's
+ * activation request in the very transaction that saves the message, so the
+ * message and its activation intent commit together and no "submit then
+ * activate" two-command window exists. It reuses this exact logic rather than a
+ * second activation queue: the same idempotency, settled-id refusal and
+ * pending-collision rules apply whether the request arrives from the explicit
+ * boundary or from a develop submission. The caller owns transaction lifetime
+ * and any post-commit mailbox notification.
+ */
+export function recordTaskActivationRequestInTransaction(tx, input, now) {
+    const task = requireOpenDraft(tx, input.taskId);
+    const plan = canonicalEnvironmentPlan(input.environmentPlan);
+    const planningRun = resolveCallerPlanningRun(tx, task.id, input.callerRunId);
+    const startMode = planningRun === undefined
+        ? "immediate"
+        : "after-planning-turn";
+    const existing = task.activationRequest;
+    // A requestId whose outcome was already decided is never re-opened, whether
+    // it still holds the slot or a later request displaced it. Cancelling A,
+    // requesting B and then retrying A must not resurrect A: the withdrawal is
+    // explicit authority, and adoption is exactly the effect it withdrew. An
+    // adopted id is equally final — its environment and status change happened.
+    // Only `failed` stays replayable, which is its documented contract.
+    //
+    // The authority is the durable activation event ledger, not the bounded
+    // display payload: the payload trims its oldest entries once it overflows,
+    // but the terminal events are never compacted, so an evicted cancellation is
+    // still refused with its original outcome instead of silently resurrecting.
+    const settled = settledActivationRequest(tx, task, input.requestId);
+    if (settled !== undefined) {
+        throw new Error(`Activation request ${input.requestId} was already ${settled.disposition} for ${task.id}`
+            + `${settled.outcome === undefined ? "" : ` (${settled.outcome})`}. `
+            + "Use a new requestId.");
+    }
+    if (existing?.operation.requestId === input.requestId) {
+        const digest = taskActivationInputDigest(task.id, {
             startMode,
             ...(planningRun === undefined ? {} : { afterPlanningRun: planningRun }),
             environmentPlan: plan
-        }, now);
-        tx.saveTask(setTaskActivationRequest(task, request, now));
-        tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, TASK_ACTIVATION_EVENT.requested, {
-            requestId: request.operation.requestId,
-            startMode: request.startMode,
-            environmentPlan: describeEnvironmentPlan(request.environmentPlan),
-            actor: request.operation.actorId,
-            ...(request.afterPlanningRun === undefined
-                ? {}
-                : { afterPlanningRun: request.afterPlanningRun })
-        }, now));
+        });
+        if (existing.operation.inputDigest !== digest) {
+            throw new Error(`Activation requestId ${input.requestId} was already used for different inputs.`);
+        }
         return {
-            operationRef: taskActivationOperationRef(task.id, request.operation.requestId),
-            request,
-            startMode,
-            created: true,
-            ...(planningRun === undefined ? {} : { afterPlanningRun: planningRun })
+            operationRef: taskActivationOperationRef(task.id, existing.operation.requestId),
+            request: existing,
+            startMode: existing.startMode,
+            created: false,
+            ...(existing.afterPlanningRun === undefined
+                ? {}
+                : { afterPlanningRun: existing.afterPlanningRun })
         };
-    });
+    }
+    if (existing?.disposition === "pending") {
+        throw new Error(`Task already has a pending activation request: ${task.id}/${existing.operation.requestId}. `
+            + "Cancel it before requesting different inputs.");
+    }
+    const request = createTaskActivationRequest(task.id, {
+        requestId: input.requestId,
+        actorId: input.actorId,
+        authorityRef: input.authorityRef,
+        startMode,
+        ...(input.origin === undefined ? {} : { origin: input.origin }),
+        ...(planningRun === undefined ? {} : { afterPlanningRun: planningRun }),
+        environmentPlan: plan
+    }, now);
+    tx.saveTask(setTaskActivationRequest(task, request, now));
+    tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, TASK_ACTIVATION_EVENT.requested, {
+        requestId: request.operation.requestId,
+        startMode: request.startMode,
+        environmentPlan: describeEnvironmentPlan(request.environmentPlan),
+        actor: request.operation.actorId,
+        ...(request.origin === undefined ? {} : { origin: request.origin }),
+        ...(request.afterPlanningRun === undefined
+            ? {}
+            : { afterPlanningRun: request.afterPlanningRun })
+    }, now));
+    return {
+        operationRef: taskActivationOperationRef(task.id, request.operation.requestId),
+        request,
+        startMode,
+        created: true,
+        ...(planningRun === undefined ? {} : { afterPlanningRun: planningRun })
+    };
 }
 /** Explicit user or Operator cancellation. A cancelled request never adopts. */
 export function cancelTaskActivation(store, taskId, requestId, reason, now) {

package/dist/task/taskSubmission.js

@@ -0,0 +1,236 @@
+import { SYSTEM_LEADER_ROLE } from "../role/systemRoles.js";
+/**
+ * Requirement A phase and routing derivation (task-32 §2.1, §2.2).
+ *
+ * `Task.status` stays the only lifecycle statement. "Entered planning" is a
+ * derived fact, never a writable second state: this module reads it from the
+ * durable evidence a legitimate planning entry leaves behind, so idleness, a
+ * failed or replaced Session, a Controller restart, or a trimmed Context can
+ * never reset it to "not planned".
+ */
+/**
+ * The never-compacted event that records a Draft was routed into planning by an
+ * accepted user/operator submission, inside the same transaction that saved the
+ * message. It is one of the three independent derivation sources below, and the
+ * only one the shared submission service itself writes; the others are produced
+ * by the planning Run and its Session. Migration appends the same event for
+ * legitimate historical discussions so a post-upgrade develop cannot snatch a
+ * mid-discussion Draft into auto-activation.
+ */
+export const TASK_PLANNING_ENTERED_EVENT = "task.planning-entered";
+/**
+ * Whether this Draft has already entered planning (task-32 §2.2).
+ *
+ * Derived — never a stored flag — from any of three independent, monotonic
+ * sources, each of which only ever comes into existence and never legitimately
+ * disappears:
+ *
+ *  (a) a persisted planning-entered event, written in the message-save
+ *      transaction the first time an accepted submission routed to planning;
+ *  (b) a Leader planning AgentRun in history (the first-discuss Run, once the
+ *      Controller has created it);
+ *  (c) a Leader Session whose frozen launch carried planning authority.
+ *
+ * A role being configured, a non-empty body, or a non-empty Brief are
+ * deliberately NOT evidence: none of them proves the user's submission was ever
+ * accepted and routed. Only a Draft can be "in planning"; an active or terminal
+ * Task is past the question and answers false.
+ */
+export function draftHasEnteredPlanning(store, task) {
+    if (task.status !== "draft")
+        return false;
+    return hasPlanningEnteredEvent(store.listEvents(task.id))
+        || hasLeaderPlanningRun(store, task.id)
+        || hasLeaderPlanningSession(store, task.id);
+}
+function hasPlanningEnteredEvent(events) {
+    return events.some((event) => event.type === TASK_PLANNING_ENTERED_EVENT);
+}
+function hasLeaderPlanningRun(store, taskId) {
+    return store.listRuns(taskId).some((run) => run.roleName === SYSTEM_LEADER_ROLE && run.purpose === "planning");
+}
+function hasLeaderPlanningSession(store, taskId) {
+    const sessions = store.getTaskRoleSessionSet(taskId, SYSTEM_LEADER_ROLE);
+    if (sessions === null)
+        return false;
+    const candidates = [
+        ...Object.values(sessions.sessions ?? {}),
+        ...(sessions.history ?? [])
+    ];
+    return candidates.some((session) => session.effective.executionAuthority === "planning");
+}
+export function draftActivationState(request) {
+    if (request === undefined)
+        return "none";
+    switch (request.disposition) {
+        case "pending": return "pending";
+        case "failed": return "failed";
+        case "adopted": return "adopted";
+        case "cancelled": return "none";
+        default: return "none";
+    }
+}
+/**
+ * Decide how a user/operator submission routes, given its normalized intent and
+ * the phase/activation facts read inside the save transaction.
+ *
+ * This is a pure decision over already-read facts, kept separate from the
+ * transaction that saves the message and enqueues work so it can be unit-tested
+ * exhaustively against the §2.1 table without a Store. The winner of a race is
+ * decided by which submission's transaction commits first: the second one reads
+ * the phase/activation the first one already wrote and routes accordingly.
+ *
+ * `executionEnabled` is the Task's own gate, read in the same transaction. It
+ * only ever gates a *fresh* develop activation: recording an activation request
+ * against a stopped Draft is refused at the activation boundary, so routing that
+ * case to `activate` would abort the whole transaction and lose the saved
+ * message. Planning and already-open activation obligations are unaffected — the
+ * gate is enforced later at dispatch, exactly as it is for a plain message.
+ */
+export function decideSubmissionRouting(input) {
+    // record never wakes anything, in any state (§2.1 first column).
+    if (input.intent === "record")
+        return { kind: "record" };
+    if (input.status === "active") {
+        // Neither discuss nor develop re-activates or downgrades an active Task.
+        return { kind: "active-context" };
+    }
+    // Only Draft remains: terminal statuses are refused before routing (§2.1 last
+    // row) by the caller's assertTaskOpen, so this function is never asked about
+    // them.
+    if (input.activation === "pending") {
+        return input.intent === "develop"
+            // A compatible pending request already exists; reference it, never a
+            // second request (§2.3 "重复 develop 不产生第二个兼容激活请求").
+            ? { kind: "await-activation", state: "pending" }
+            // discuss becomes post-activation input; it does not start new planning.
+            : { kind: "await-activation", state: "pending" };
+    }
+    if (input.activation === "failed") {
+        // develop never auto-retries or downgrades to planning; discuss reports the
+        // original failure and the explicit retry/cancel next step. Both save only.
+        return { kind: "await-activation", state: "failed" };
+    }
+    if (input.intent === "develop") {
+        // develop on an already-planned Draft never auto-activates — it needs
+        // explicit manual activation. On an unplanned Draft with no open activation
+        // it records the request and routes to activation, unless execution is
+        // stopped: then the message is saved but no activation is recorded.
+        if (input.enteredPlanning)
+            return { kind: "planned-needs-manual-activation" };
+        return input.executionEnabled
+            ? { kind: "activate", environmentPlan: input.developEnvironmentPlan }
+            : { kind: "activation-blocked-execution-stopped" };
+    }
+    // discuss (the default): first discussion records the planning entry; later
+    // discussion continues the existing planning conversation.
+    return input.enteredPlanning
+        ? { kind: "continue-planning" }
+        : { kind: "enter-planning" };
+}
+/**
+ * Normalize a possibly-absent submission intent to its effective value.
+ *
+ * An absent intent is `discuss` (task-32 §2.5: "默认/旧客户端都按 discuss"), so
+ * every old client and every message saved before the field existed keeps its
+ * historical Leader-waking behaviour. Body text is never inspected.
+ *
+ * A legacy `--wake-policy none` carried the "save only, do not wake" meaning that
+ * `record` now names, so a caller that supplied only that older signal maps to
+ * `record` rather than silently becoming a Leader-waking `discuss`. An explicit
+ * intent always wins over the wake-policy shorthand.
+ */
+export function normalizeSubmissionIntent(intent, wakePolicy) {
+    if (intent !== undefined)
+        return intent;
+    if (wakePolicy === "none")
+        return "record";
+    return "discuss";
+}
+/**
+ * Whether a retry aims at the same target the key was first bound to (§2.3). An
+ * absent prior target (a keyed Message from before receipts existed) never
+ * matches, so such a Message is treated as a conflict rather than replayed from
+ * a fabricated disposition.
+ */
+export function sameSubmissionTarget(prior, next) {
+    if (prior === undefined || prior.kind !== next.kind)
+        return false;
+    if (prior.kind === "task" && next.kind === "task")
+        return prior.taskId === next.taskId;
+    return true;
+}
+/**
+ * Derive the §2.5 feedback for one committed submission from its routing and the
+ * facts read in the save transaction.
+ *
+ * Pure over already-read facts, so it is unit-testable against the whole table
+ * without a Store. `enteredPlanning` and `activationState` are the values read
+ * before routing executed; the routing itself names what the transaction then
+ * did, and phase is derived to reflect the post-commit truth (a just-entered
+ * planning Draft reports `draft-planning`).
+ */
+export function describeSubmissionFeedback(input) {
+    const { routing } = input;
+    const phase = input.status === "active"
+        ? "active"
+        : routing.kind === "enter-planning"
+            || routing.kind === "continue-planning"
+            || routing.kind === "planned-needs-manual-activation"
+            || input.enteredPlanning
+            ? "draft-planning"
+            : "draft-unplanned";
+    const planning = routing.kind === "enter-planning"
+        ? "entered"
+        : routing.kind === "continue-planning"
+            ? "continued"
+            : "none";
+    const activation = routing.kind === "activate"
+        ? "requested"
+        : routing.kind === "planned-needs-manual-activation"
+            ? "manual-required"
+            : routing.kind === "activation-blocked-execution-stopped"
+                ? "execution-stopped"
+                : routing.kind === "await-activation"
+                    ? routing.state
+                    // record and the planning routes report the existing obligation, if
+                    // any, truthfully without acting on it.
+                    : input.activationState === "pending"
+                        ? "pending"
+                        : input.activationState === "failed"
+                            ? "failed"
+                            : "none";
+    const delivery = routing.kind === "enter-planning"
+        || routing.kind === "continue-planning"
+        || routing.kind === "active-context"
+        ? "queued"
+        : "none";
+    const nextStep = submissionNextStep(input);
+    return {
+        saved: { taskId: input.taskId, messageId: input.messageId },
+        phase,
+        planning,
+        activation,
+        delivery,
+        ...(nextStep === undefined ? {} : { nextStep })
+    };
+}
+function submissionNextStep(input) {
+    if (input.routing.kind === "planned-needs-manual-activation") {
+        return { kind: "activate-manually", taskId: input.taskId };
+    }
+    if (input.routing.kind === "activation-blocked-execution-stopped") {
+        return { kind: "start-execution", taskId: input.taskId };
+    }
+    if (input.routing.kind === "await-activation") {
+        if (input.routing.state === "failed") {
+            return {
+                kind: "resolve-failed-activation",
+                activationRef: input.activationRef ?? "",
+                failure: input.activationFailure ?? "activation failed"
+            };
+        }
+        return { kind: "await-pending-activation", activationRef: input.activationRef ?? "" };
+    }
+    return undefined;
+}

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

@@ -128,8 +128,9 @@ function detailActions() {
     answerInput: answerInput,
     openTerminal: openTerminal,
     inspect: inspectRecord,
-    sendMessage: (taskId, body, requestId) => submitMutation(taskId + "/messages",
-      "/api/tasks/" + encodeURIComponent(taskId) + "/messages", { body, requestId }),
+    sendMessage: (taskId, body, requestId, intent) => submitMutation(taskId + "/messages",
+      "/api/tasks/" + encodeURIComponent(taskId) + "/messages",
+      { body, requestId, ...(intent === undefined ? {} : { intent }) }),
     updateTask: (taskId, patch, requestId) => submitMutation(taskId + "/metadata",
       "/api/tasks/" + encodeURIComponent(taskId) + "/metadata", { patch, requestId }),
     panels: (taskId) => requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/panels",

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

@@ -33,27 +33,47 @@ export function renderTaskSurface(container, data, t, locale, actions) {
   message.required = true;
   message.maxLength = 8000;
   chatLabel.append(message);
+  // Submission intent is an explicit user choice, never inferred from the body
+  // (task-32 §2.5); discuss is the default so the control matches the service.
+  const intentLabel = node("label", "", say("Intent", "提交意图"));
+  const intentSelect = node("select", "");
+  const intentOptions = [
+    ["discuss", say("Discuss — route to planning", "讨论 — 进入规划")],
+    ["record", say("Record — save only", "记录 — 仅保存")],
+    ["develop", say("Develop — request activation", "开发 — 请求激活")]
+  ];
+  for (const [value, text] of intentOptions) {
+    const option = node("option", "", text);
+    option.value = value;
+    intentSelect.append(option);
+  }
+  intentSelect.value = "discuss";
+  intentLabel.append(intentSelect);
   chat.addEventListener("input", () => { chat.dataset.unsent = message.value ? "true" : "false"; });
   const send = node("button", "record-open", say("Send", "发送"));
   send.type = "submit";
   send.disabled = !["active", "draft"].includes(task.status);
   const sent = node("p", "muted", say("Not submitted", "未提交"));
   sent.setAttribute("role", "status");
-  chat.append(chatLabel, send, sent);
+  // §2.5 facets render here, one per line; cleared and repopulated on every submit.
+  const facets = node("div", "section-body");
+  facets.dataset.submissionFacets = "";
+  chat.append(chatLabel, intentLabel, send, sent, facets);
   chat.addEventListener("submit", async (event) => {
     event.preventDefault();
     if (send.disabled) return;
     send.disabled = true;
     chat.dataset.unsent = "true";
     const requestId = crypto.randomUUID();
+    const intent = intentSelect.value;
+    clear(facets);
     sent.textContent = say("Waiting for receipt · ", "等待回执 · ") + requestId;
     try {
-      const receipt = await actions.sendMessage(task.id, message.value, requestId);
-      sent.textContent = (receipt.disposition === "queued"
-        ? say("Queued for Leader; not proof of execution · ", "已为 Leader 排队，不代表已执行 · ")
-        : say("Saved to Task context; this Task's Leader is not waking · ",
-          "已保存到 Task 上下文；该 Task 的 Leader 不会被唤醒 · "))
-        + receipt.record.id;
+      // requestId is the submission key: the same key retried returns the original
+      // Message and routing rather than a second submission (task-32 §2.3).
+      const receipt = await actions.sendMessage(task.id, message.value, requestId, intent);
+      sent.textContent = say("Saved · ", "已保存 · ") + receipt.record.id;
+      renderSubmissionFacets(facets, receipt.submission, say);
       message.value = "";
       chat.dataset.unsent = "false";
       send.disabled = false;
@@ -63,6 +83,9 @@ export function renderTaskSurface(container, data, t, locale, actions) {
         send.disabled = false;
         return;
       }
+      // A lost response must never auto-replay a write; the same requestId is safe
+      // to resend by hand because the server dedups on it (§2.3), but the user
+      // reloads and inspects first rather than blindly resending.
       sent.textContent = say("Unknown submission outcome. Reload and inspect saved messages before sending again · ",
         "提交结果未知。请重新加载并检查已保存消息，不要盲目重发 · ") + requestId;
     }
@@ -350,4 +373,70 @@ export function renderTaskSurface(container, data, t, locale, actions) {
   scaffold.append(panels);
   container.append(scaffold);
 }
+
+// Render each task-32 §2.5 submission facet on its own line, never collapsed into
+// a single "started". This repo has one current server contract: every submission
+// returns its faceted receipt, so there is no old-server flat-disposition path to
+// fall back to. A missing facet block is a contract violation, reported as a
+// limited diagnostic rather than reinterpreted as a plausible flat result.
+function renderSubmissionFacets(container, submission, say) {
+  clear(container);
+  if (!submission) {
+    container.append(node("p", "muted",
+      say("Submission receipt is missing its §2.5 facets.", "提交回执缺少 §2.5 分面字段。")));
+    return;
+  }
+  const phaseText = {
+    "active": say("Active — delivery context", "进行中 — 交付上下文"),
+    "draft-planning": say("Draft, in planning", "草稿，规划中"),
+    "draft-unplanned": say("Draft, not yet planned", "草稿，尚未规划")
+  };
+  const planningText = {
+    "entered": say("Entered planning", "已进入规划"),
+    "continued": say("Continued planning", "继续规划"),
+    "none": say("No planning change", "规划无变化")
+  };
+  const activationText = {
+    "requested": say("Activation requested", "已请求激活"),
+    "pending": say("Activation pending", "激活待处理"),
+    "failed": say("Activation failed", "激活失败"),
+    "manual-required": say("Manual activation required", "需手动激活"),
+    "execution-stopped": say("Execution stopped; not activated", "执行已停止；未激活"),
+    "none": say("No activation", "无激活")
+  };
+  const deliveryText = {
+    "queued": say("Leader queued to act now", "已为 Leader 排队处理"),
+    "none": say("Leader not woken", "未唤醒 Leader")
+  };
+  const facts = [
+    [say("Phase", "阶段"), phaseText[submission.phase] ?? submission.phase],
+    [say("Planning", "规划"), planningText[submission.planning] ?? submission.planning],
+    [say("Activation", "激活"), activationText[submission.activation] ?? submission.activation],
+    [say("Delivery", "投递"), deliveryText[submission.delivery] ?? submission.delivery]
+  ];
+  for (const [label, value] of facts) {
+    container.append(node("p", "muted", label + ": " + value));
+  }
+  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 + "）。")
+      : step.kind === "start-execution"
+      ? say("Next: start execution first, then activate (" + step.taskId + ").",
+        "下一步：先启动执行，再激活（" + step.taskId + "）。")
+      : step.kind === "await-pending-activation"
+      ? say("Next: waiting on the pending activation " + step.activationRef + ".",
+        "下一步：等待待处理的激活 " + step.activationRef + "。")
+      : step.kind === "resolve-failed-activation"
+      ? say("Next: the prior activation failed (" + step.failure + "); retry with a new request or cancel " + step.activationRef + ".",
+        "下一步：之前的激活失败（" + step.failure + "）；请用新请求重试或取消 " + step.activationRef + "。")
+      : "";
+    if (nextText) {
+      const next = node("p", "", nextText);
+      next.dataset.nextStep = step.kind;
+      container.append(next);
+    }
+  }
+}
 `;

package/dist/web/webServer.js

@@ -3,6 +3,7 @@ import { createServer } from "node:http";
 import WebSocket, { WebSocketServer } from "ws";
 import { usageError } from "../errors/cliError.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";
 const MAX_JSON_BODY_BYTES = 16 * 1024;
@@ -160,11 +161,13 @@ async function handleHttpRequest(request, response, store, dependencies, token,
             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))
+                    || Object.keys(body).some((key) => !["body", "requestId", "intent"].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 };
+                    throw new WebRequestRejected("Expected body, requestId and optional intent.");
+                const intent = webSubmissionIntent(body);
+                // requestId is threaded as the submission key (§2.3) and echoed back on the receipt.
+                value = { ...dependencies.surface.message(taskId, body.body, intent, body.requestId), requestId: body.requestId };
             }
             else if (method === "POST" && action === "metadata") {
                 const body = await readMutationBody(request);
@@ -450,6 +453,18 @@ async function readMutationBody(request) {
         throw new WebRequestRejected(error instanceof Error ? error.message : "Invalid request body.");
     }
 }
+/** Validate an optional submission intent from a Web message body. Absent leaves
+ *  it undefined so the shared service applies the discuss default (task-32 §2.5).
+ *  A present-but-invalid value is rejected rather than silently downgraded. */
+function webSubmissionIntent(body) {
+    if (!("intent" in body) || body.intent === undefined)
+        return undefined;
+    if (typeof body.intent === "string"
+        && TASK_SUBMISSION_INTENTS.includes(body.intent)) {
+        return body.intent;
+    }
+    throw new WebRequestRejected(`intent must be one of ${TASK_SUBMISSION_INTENTS.join(", ")}.`);
+}
 async function readJsonBody(request) {
     const chunks = [];
     let size = 0;

package/dist/web/webTaskSurface.js

@@ -22,16 +22,16 @@ export function createWebTaskSurface(store, options = {}, observations = []) {
             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));
+        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),