@zq-silk/yui 0.15.8 → 0.15.11

package/dist/task/nextAction.js

@@ -121,6 +121,16 @@ export function projectNextAction(facts) {
             recommendedCommand: `yui task activate ${task.id}`
         });
     }
+    const conflictedIntegration = facts.integrations.find(attempt => attempt.status === "conflicted");
+    if (conflictedIntegration !== undefined) {
+        return buildAction(facts, {
+            kind: "resolve-integration-conflicts",
+            reason: `Integration ${conflictedIntegration.id} has Git conflicts; the Leader resolves its workspace and continues without prior resolve or user approval.`,
+            refs: [ref("integration", conflictedIntegration.id)],
+            preconditions: [{ fact: "Git conflict resolution belongs to the Leader", satisfied: true }],
+            recommendedCommand: `yui task integration continue ${task.id}/${conflictedIntegration.id}`
+        });
+    }
     const checkingIntegration = facts.integrations.find(attempt => attempt.status === "running" && attempt.jobId !== undefined);
     if (checkingIntegration !== undefined) {
         const job = facts.integrationJobs?.find(job => job.id === checkingIntegration.jobId);
@@ -146,6 +156,21 @@ export function projectNextAction(facts) {
             recommendedCommand: `yui task integration continue ${task.id}/${checkingIntegration.id}`
         });
     }
+    const unfinishedIntegration = facts.integrations.find(attempt => attempt.status === "running" || attempt.status === "validating");
+    if (unfinishedIntegration !== undefined) {
+        return buildAction(facts, {
+            kind: "integrate-work-item",
+            reason: `Integration ${unfinishedIntegration.id} is unfinished. ${unfinishedIntegration.summary ?? "Continue from its persisted source and check evidence."}`,
+            refs: [ref("integration", unfinishedIntegration.id)],
+            preconditions: [{ fact: "Inspect exact Integration evidence before any retry", satisfied: true }],
+            recommendedCommand: `yui task integration continue ${task.id}/${unfinishedIntegration.id}`,
+            alternatives: [{
+                    kind: "inspect-integration",
+                    reason: "If completion cannot be proved, preserve evidence and choose formal abort and an authorized alternative.",
+                    recommendedCommand: `yui task integration show ${task.id}/${unfinishedIntegration.id}`
+                }]
+        });
+    }
     const candidateReady = facts.workItems
         .find((item) => (item.status === "open" && item.currentCandidateId !== undefined));
     if (candidateReady !== undefined) {
@@ -320,27 +345,35 @@ export function projectNextAction(facts) {
             return synthesisSelectionAction(facts, "work", item.id);
         }
         const refs = [ref("work-item", item.id)];
+        const direct = item.assignee === undefined;
         return buildAction(facts, {
             kind: "implement-current-work-item",
-            reason: `Work Item ${item.id} is ${item.status}; dispatch or continue its implementation.`,
+            reason: direct
+                ? `Work Item ${item.id} has no managed assignee; the Leader can execute it directly.`
+                : `Work Item ${item.id} is assigned to ${item.assignee}; dispatch or continue that assignment.`,
             refs,
             preconditions: [
                 { fact: `Work Item is ${item.status}`, satisfied: true, ref: refs[0] }
             ],
-            recommendedCommand: `yui task work dispatch ${task.id}/${item.id}`,
-            alternatives: [
-                {
-                    kind: "execute-directly",
-                    reason: "Execute the bounded Work Item directly when the Leader's current context and authority are sufficient.",
-                    refs
-                },
+            recommendedCommand: direct
+                ? `yui task work update ${task.id}/${item.id} running`
+                : `yui task work dispatch ${task.id}/${item.id}`,
+            alternatives: direct ? [
+                ...(item.writeProjectIds.length === 0 ? [] : [{
+                        kind: "isolate-work-item",
+                        reason: "Prepare and inspect the WorkItem-owned code workspace before direct implementation.",
+                        recommendedCommand: `yui task work isolate ${task.id}/${item.id}`,
+                        refs
+                    }]),
                 {
                     kind: "native-subagent",
-                    reason: "Use native implementer subagents when bounded work benefits from specialist attention or parallel fan-out inside the Leader Session.",
+                    reason: "Use a bounded native child only when authorized and useful within the Leader's current scope.",
                     refs
                 }
-            ],
-            judgmentRequired: "Leader must choose the execution path: direct execution, a native subagent, or managed Task Role dispatch."
+            ] : [],
+            judgmentRequired: direct
+                ? "Honor explicit execution preferences. For code, use the WorkItem-owned workspace and integrate its Candidate before acceptance; no self-dispatch is needed."
+                : "Preserve the current managed Assignment and original results; do not switch ownership merely to follow a different default."
         });
     }
     if (deliveryWorkItems.length === 0

package/dist/task/taskActivation.js

@@ -22,6 +22,7 @@ export const TASK_ACTIVATION_EVENT = Object.freeze({
     adopted: "task.activation-adopted",
     failed: "task.activation-failed"
 });
+export const TASK_ACTIVATION_ORIGINS = Object.freeze(["explicit", "submit-develop"]);
 /**
  * The digest that decides whether a repeated requestId is the same request.
  *
@@ -63,6 +64,7 @@ export function createTaskActivationRequest(taskId, input, now) {
             partialResultRefs: []
         },
         startMode: input.startMode,
+        ...(input.origin === undefined ? {} : { origin: input.origin }),
         ...(input.afterPlanningRun === undefined
             ? {}
             : { afterPlanningRun: input.afterPlanningRun }),
@@ -194,6 +196,26 @@ export function admitTaskActivationRequest(task, request, planningRunIsActive) {
     }
     return { disposition: "ready", request };
 }
+/**
+ * Whether the Controller may continue (auto-adopt) a released request without an
+ * explicit activation boundary call (task-32 §2.4).
+ *
+ * A deferred request already holds activation authority and is released by its
+ * planning Turn ending, so it is adoptable regardless of origin. An immediate
+ * request is auto-continued only when it carries a recognised provable origin:
+ * an explicit activation action, or a develop submission the shared transaction
+ * accepted while the Task was unplanned. A request with no origin — every one
+ * migrated from before the field existed — is deliberately held back so an
+ * upgrade cannot turn a historical pending request into a silent activation; it
+ * still adopts through the explicit `yui task activate` boundary, which does not
+ * consult origin. This replaces the old actor heuristic that both dropped legal
+ * Operator/user immediate requests and could not distinguish provenance.
+ */
+export function activationRequestIsControllerAdoptable(request) {
+    if (request.startMode === "after-planning-turn")
+        return true;
+    return request.origin !== undefined;
+}
 /**
  * The durable terminal outcome for a requestId, read from the activation event
  * ledger.
@@ -236,6 +258,10 @@ export function validateTaskActivationRequest(request) {
     if (!["immediate", "after-planning-turn"].includes(request.startMode)) {
         throw new Error(`Activation start mode is invalid: ${String(request.startMode)}.`);
     }
+    if (request.origin !== undefined
+        && !TASK_ACTIVATION_ORIGINS.includes(request.origin)) {
+        throw new Error(`Activation origin is invalid: ${String(request.origin)}.`);
+    }
     if ((request.startMode === "after-planning-turn")
         !== (request.afterPlanningRun !== undefined)) {
         throw new Error("Activation deferral must name exactly the planning Turn it waits for.");

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,11 @@ 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 }) }),
+    controlInput: (taskId, payload, requestId) => submitMutation(taskId + "/control/" + requestId,
+      "/api/tasks/" + encodeURIComponent(taskId) + "/control", payload),
     updateTask: (taskId, patch, requestId) => submitMutation(taskId + "/metadata",
       "/api/tasks/" + encodeURIComponent(taskId) + "/metadata", { patch, requestId }),
     panels: (taskId) => requestJson("/api/tasks/" + encodeURIComponent(taskId) + "/panels",
@@ -658,9 +661,62 @@ elements.refresh.addEventListener("click", function () { refreshDashboard(); });
 elements.operatorTerminal.addEventListener("click", function () {
   openTerminal({ scope: "global", roleName: "operator" });
 });
+const globalDialog = document.querySelector("#global-input-dialog");
+const globalForm = document.querySelector("#global-input-form");
+const globalRole = document.querySelector("#global-input-role");
+const globalAction = document.querySelector("#global-input-action");
+const globalBody = document.querySelector("#global-input-body");
+const globalTarget = document.querySelector("#global-input-target");
+const globalThen = document.querySelector("#global-input-then");
+const globalSubmit = document.querySelector("#global-input-submit");
+const globalReceipt = document.querySelector("#global-input-receipt");
+const globalState = document.querySelector("#global-input-state");
+document.querySelector("#global-input-open").addEventListener("click", () => globalDialog.showModal());
+document.querySelector("#global-input-close").addEventListener("click", () => globalDialog.close());
+globalAction.addEventListener("change", () => {
+  document.querySelector("#global-input-body-label").hidden = globalAction.value === "interrupt";
+  document.querySelector("#global-input-target-label").hidden = globalAction.value === "queue";
+  document.querySelector("#global-input-then-label").hidden = globalAction.value !== "interrupt";
+  globalBody.required = globalAction.value !== "interrupt";
+  globalTarget.required = globalAction.value !== "queue";
+});
+document.querySelector("#global-input-inspect").addEventListener("click", async () => {
+  try {
+    const facts = await requestJson("/api/roles/" + encodeURIComponent(globalRole.value.trim()) + "/control");
+    globalState.textContent = JSON.stringify(facts, null, 2);
+    globalTarget.value = facts.turn?.nativeTurnId || facts.turn?.attemptId || "";
+  } catch (error) { globalState.textContent = error.message; }
+});
+globalForm.addEventListener("submit", async event => {
+  event.preventDefault();
+  if (globalSubmit.disabled) return;
+  globalSubmit.disabled = true;
+  const role = globalRole.value.trim();
+  const action = globalAction.value;
+  const requestId = crypto.randomUUID();
+  const input = { action, requestId };
+  if (action !== "interrupt") input.body = globalBody.value;
+  if (action !== "queue") input.expectedTarget = globalTarget.value.trim();
+  if (action === "interrupt" && globalThen.value.trim()) input.thenMessage = globalThen.value.trim();
+  globalReceipt.textContent = "Waiting for receipt · 等待回执 · " + requestId;
+  try {
+    const receipt = await submitMutation("global/" + role, "/api/roles/" + encodeURIComponent(role) + "/control", input);
+    const status = receipt.steer || receipt.interrupt || receipt.delivery || {};
+    globalReceipt.textContent = JSON.stringify(receipt);
+    const unknown = ["pending", "delivery-unknown", "steer-unknown", "interrupt-unknown"].includes(status.state)
+      || status.code === "DELIVERY_UNKNOWN";
+    globalSubmit.disabled = unknown;
+    if (!unknown && !status.code) globalBody.value = "";
+  } catch (error) {
+    globalReceipt.textContent = error.disposition === "not-submitted" ? error.message
+      : "Outcome unknown; read state before acting. 结果未知，请先读取状态，不要重发。 · " + requestId;
+    globalSubmit.disabled = error.disposition !== "not-submitted";
+  }
+});
 elements.detailBack.addEventListener("click", clearSelection);
 elements.terminalClose.addEventListener("click", closeTerminalPanel);
 document.addEventListener("keydown", function (event) {
+  if (globalDialog.open) return;
   const active = document.activeElement;
   const typing = active && ["INPUT", "SELECT", "TEXTAREA"].includes(active.tagName);
   if (event.key === "Escape" && terminalPanelOpen()) {

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

@@ -107,6 +107,7 @@ const EXEC_STATUS_TONE = {
   "attention": "is-danger",
   "progressing-with-attention": "is-warning",
   "blocked": "is-danger",
+  "conflicted": "is-warning",
   "working": "is-active",
   "completed": "is-muted",
   "retired": "is-muted",