@zq-silk/yui 2.8.0 → 2.9.0

package/dist/cli/commandCatalog.js

@@ -314,8 +314,8 @@ const taskChildren = [
                 name: "request", discovery: { surface: "public", audiences: ["public", "operator", "leader"] },
                 summary: "Record an Activation request. Every active Task gets a managed main workspace. empty adds no execution environment; scratch adopts a separate scratch environment; local requires a registered Resource and grant, not a Project ID.",
                 usage: "yui task activation request <task> --request-id <id> "
-                    + "--environment <empty|scratch|local:<resource>:<read|write>>",
-                options: ["--request-id", "--environment"],
+                    + "--environment <empty|scratch|local:<resource>:<read|write>> [--source-message <id> | --source-text <exact-input>]",
+                options: ["--request-id", "--environment", "--source-message", "--source-text"],
                 examples: [
                     "yui task activation request <task> --request-id start-1 --environment empty",
                     "yui task activation request <task> --request-id start-1 --environment scratch"
@@ -643,8 +643,8 @@ const taskChildren = [
             {
                 name: "upsert", discovery: { surface: "managed", audiences: ["operator", "leader"] },
                 summary: "Create or immutably update an external PR/MR and its publication state.",
-                usage: "yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--head-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported|--verified] [--evidence <text>] [--merged-at <iso-timestamp>]",
-                options: ["--project", "--provider", "--repository", "--kind", "--id", "--url", "--title", "--source-branch", "--target-branch", "--local-commit", "--head-commit", "--remote-commit", "--state", "--reported", "--verified", "--evidence", "--merged-at"]
+                usage: "yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--head-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported] [--evidence <text>] [--merged-at <iso-timestamp>]",
+                options: ["--project", "--provider", "--repository", "--kind", "--id", "--url", "--title", "--source-branch", "--target-branch", "--local-commit", "--head-commit", "--remote-commit", "--state", "--reported", "--evidence", "--merged-at"]
             },
             {
                 name: "diff", discovery: { surface: "managed", audiences: ["operator", "leader"] },
@@ -660,8 +660,9 @@ const taskChildren = [
             },
             {
                 name: "verify", discovery: { surface: "managed", audiences: ["operator", "leader"] },
-                summary: "Observe the current PR/MR head and merge through its provider; record verification separately from Task coverage.",
-                usage: "yui task publication verify (<task>/<publication-id> | <task> <publication-id>)"
+                summary: "Record exact authorized tool evidence, or query the optional gh/glab adapter; verification is separate from Task coverage.",
+                usage: "yui task publication verify (<task>/<publication-id> | <task> <publication-id>) [--observation <json>]",
+                options: ["--observation"]
             },
             {
                 name: "list", discovery: { surface: "public", audiences: ["public", "operator", "leader"] },
@@ -1016,15 +1017,15 @@ const taskChildren = [
     },
     {
         name: "brief", discovery: { surface: "managed", audiences: ["operator", "leader"] },
-        summary: "Manage the Task Brief, the authoritative summary of current task state.",
+        summary: "Manage the Leader-maintained Task summary; live lifecycle and authority remain separate facts.",
         sections: [{ id: "manage", title: "Commands", entries: ["show", "update"] }],
         children: [
             { name: "show", discovery: { surface: "managed", audiences: ["operator", "leader"] }, summary: "Show the Task Brief.", usage: "yui task brief show <task> [--cursor <cursor>]", options: ["--cursor"] },
             {
                 name: "update", discovery: { surface: "managed", audiences: ["operator", "leader"] },
                 summary: "Create or update the Task Brief.",
-                usage: "yui task brief update <task> [--objective <text>] [--boundary <text> ...] [--approach <text>] [--focus <text>] [--leader-summary <text>]",
-                options: ["--objective", "--boundary", "--approach", "--focus", "--leader-summary"]
+                usage: "yui task brief update <task> --if-current <writeGuard> [--objective <text>] [--boundary <text> ...] [--approach <text>] [--focus <text>] [--leader-summary <text>]",
+                options: ["--if-current", "--objective", "--boundary", "--approach", "--focus", "--leader-summary"]
             }
         ]
     },
@@ -1136,7 +1137,7 @@ export const ROOT_COMMAND = buildNode({
             ] },
         { id: "workflow", title: "Workflow", entries: ["agent", "operator", "role", "inbox", "project", "task"] },
         { id: "configuration", title: "Configuration", entries: ["config"] },
-        { id: "operations", title: "Operations", entries: ["web", "controller", "session", "execution", "capability", "job", "jobs", "telemetry", "release"] },
+        { id: "operations", title: "Operations", entries: ["web", "controller", "session", "execution", "capability", "job", "schedule", "jobs", "telemetry", "release"] },
         { id: "resources", title: "Resources", entries: ["resources"] },
         { id: "internal", title: "Internal", entries: ["internal"] }
     ],
@@ -1641,15 +1642,37 @@ export const ROOT_COMMAND = buildNode({
         },
         {
             name: "job", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] },
-            summary: "Start, inspect, cancel, or acknowledge a Controller-managed DurableJob.",
-            sections: [{ id: "manage", title: "Commands", entries: ["start", "get", "cancel", "acknowledge"] }],
+            summary: "Manage stable Job definitions and exact execution Runs (not scheduler wakes).",
+            sections: [{ id: "manage", title: "Commands", entries: ["define", "update", "list", "show", "run", "runs", "run-get", "logs", "run-cancel", "run-acknowledge", "start", "get", "cancel", "acknowledge"] }],
             children: [
+                ...["define", "update", "list", "show", "run", "runs", "run-get", "logs", "run-cancel", "run-acknowledge"].map(name => ({
+                    name, discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] },
+                    summary: `${name} a stable Job or exact Run.`,
+                    usage: `yui job ${name} (--task <id>|--global)${name === "list" ? "" : " --job <id>"}`
+                        + (name === "define" || name === "update" ? " --title <text> --input <configuration-json>" : "")
+                        + (name === "update" ? " --revision <current>" : "")
+                        + (name === "run" ? " --request-id <key> [--retry-of <run-id>]" : "")
+                        + (["run-get", "logs", "run-cancel", "run-acknowledge"].includes(name) ? " --run <run-id>" : "")
+                })),
                 { name: "start", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] }, summary: "Start a DurableJob under an explicit request identity.", usage: "yui job start --request-id <id> --task <id> --project <project> --head <sha> --workspace <dir> --step <name>=<command> [--step ...] [--owner task|work-item:<id>|integration-attempt:<id>] [--env <k=v>...]" },
                 { name: "get", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] }, summary: "Show a DurableJob record and its terminal result.", usage: "yui job get --task <id> --job <job-id>" },
                 { name: "cancel", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] }, summary: "Request cancellation of a running or queued DurableJob.", usage: "yui job cancel --task <id> --job <job-id>" },
                 { name: "acknowledge", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] }, summary: "Acknowledge an unknown-needs-attention DurableJob so Task lifecycle gates can proceed.", usage: "yui job acknowledge --task <id> --job <job-id>" }
             ]
         },
+        {
+            name: "schedule", discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] },
+            summary: "Manage persistent time plans referencing scoped Jobs.",
+            sections: [{ id: "manage", title: "Commands", entries: ["create", "list", "show", "update", "enable", "disable"] }],
+            children: ["create", "list", "show", "update", "enable", "disable"].map(name => ({
+                name, discovery: { surface: "managed", audiences: ["operator", "leader", "assignment"] },
+                summary: `${name} a Schedule; disabling never cancels an admitted Run.`,
+                usage: `yui schedule ${name} (--global|--task <id>)${name === "list" ? "" : " --schedule <id>"}`
+                    + (name === "create" ? " --job <id> --rule <json>" : "")
+                    + (name === "update" ? " --rule <json> [--job <id>]" : "")
+                    + (["update", "enable", "disable"].includes(name) ? " --revision <observed>" : "")
+            }))
+        },
         {
             name: "jobs", discovery: { surface: "public", audiences: ["public", "operator"] },
             summary: "Inspect scheduler wake and recovery records.",

package/dist/cli/interactionPolicy.js

@@ -185,7 +185,7 @@ export const INTERACTION_POLICIES = Object.freeze([
                 actionTarget: true,
                 statuses: ["draft"]
             }],
-        trailingOptions: { "--request-id": "value", "--environment": "value" }
+        trailingOptions: { "--request-id": "value", "--environment": "value", "--source-message": "value", "--source-text": "value" }
     },
     {
         commandPath: ["task", "activation", "cancel"],
@@ -615,7 +615,7 @@ export const INTERACTION_POLICIES = Object.freeze([
     ].map(([group, command]) => {
         const trailingOptions = {};
         if (group === "brief" && command === "update") {
-            Object.assign(trailingOptions, { "--objective": "value", "--boundary": "value", "--approach": "value", "--focus": "value", "--leader-summary": "value" });
+            Object.assign(trailingOptions, { "--if-current": "value", "--objective": "value", "--boundary": "value", "--approach": "value", "--focus": "value", "--leader-summary": "value" });
         }
         else if (group === "decision" && command === "record") {
             Object.assign(trailingOptions, { "--title": "value", "--rationale": "value" });

package/dist/cli/updatePorts.js

@@ -776,6 +776,26 @@ function interpretPreflight(result) {
     // error is not a safe preflight — block rather than proceed to a switch.
     const data = parseSuccessEnvelopeData(result);
     if (data === null) {
+        // CLI bootstrap failures use an ok:false envelope on stderr. Preserve its
+        // already-sanitized diagnosis (including recovery guidance), never promote
+        // an error envelope to a successful storage preflight.
+        for (const stream of [result.stderr, result.stdout]) {
+            let failure;
+            try {
+                failure = JSON.parse(stream.toString("utf8").trim());
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(failure) || failure.ok !== false || typeof failure.message !== "string")
+                continue;
+            return {
+                status: "blocked",
+                stage: "preflight",
+                message: `Staged binary preflight failed (exit ${result.status ?? "null"}): ${failure.message}`,
+                action: "Resolve the reported staged-binary failure using the same Home and matching CLI; do not force the update."
+            };
+        }
         return {
             status: "blocked",
             stage: "preflight",

package/dist/commands/durableJobCommands.js

@@ -1,5 +1,6 @@
 import { usageError } from "../errors/cliError.js";
 import { ensureFileTaskController } from "../controller/clientRuntime.js";
+import { callFileTaskController } from "../controller/clientRuntime.js";
 import { acknowledgeDurableJob, cancelDurableJob, getDurableJob, startDurableJob } from "../controller/jobClient.js";
 import { resolveJobCaller, taskLocalActor } from "../task/taskAuthority.js";
 /**
@@ -14,6 +15,9 @@ export const JOB_OWNER_USAGE = "task|work-item:<id>|integration-attempt:<id>";
  */
 export async function runDurableJobCommand(args, options) {
     const [command, ...rest] = args;
+    if (command !== undefined && ["define", "update", "list", "show", "run", "runs", "run-get", "run-cancel", "run-acknowledge", "logs"].includes(command)) {
+        return definitionCommand(command, rest, options);
+    }
     if (command === "start")
         return startJob(rest, options);
     if (command === "get")
@@ -31,6 +35,52 @@ export async function runDurableJobCommand(args, options) {
         + "yui job cancel --task <id> --job <job-id>\n"
         + "yui job acknowledge --task <id> --job <job-id>");
 }
+async function definitionCommand(command, args, options) {
+    const flags = new Map();
+    for (let i = 0; i < args.length; i++) {
+        const flag = args[i];
+        if (!["--global", "--task", "--job", "--title", "--input", "--revision", "--request-id", "--retry-of", "--run"].includes(flag)
+            || flags.has(flag))
+            throw usageError(`Unknown or repeated Job flag: ${flag}.`);
+        if (flag === "--global") {
+            flags.set(flag, "true");
+            continue;
+        }
+        const value = args[++i];
+        if (value === undefined || value.startsWith("--"))
+            throw usageError(`Missing value: ${flag}.`);
+        flags.set(flag, value);
+    }
+    if (flags.has("--global") === flags.has("--task"))
+        throw usageError("Choose exactly one of --task <id> or --global.");
+    const taskId = flags.get("--task");
+    const caller = resolveJobCaller(options.environment, taskId ?? "");
+    const scope = taskId === undefined ? { kind: "global" } : { kind: "task", taskId };
+    let configuration;
+    if (flags.has("--input")) {
+        try {
+            configuration = JSON.parse(flags.get("--input"));
+        }
+        catch {
+            throw usageError("--input must be a JSON Job configuration.");
+        }
+    }
+    const requestId = flags.get("--request-id");
+    if (command === "run" && !requestId)
+        throw usageError("job run requires --request-id.");
+    const params = {
+        op: command, scope, caller,
+        ...(flags.has("--job") ? { id: flags.get("--job") } : {}),
+        ...(flags.has("--title") ? { title: flags.get("--title") } : {}),
+        ...(configuration === undefined ? {} : { configuration }),
+        ...(flags.has("--revision") ? { expectedRevision: Number(flags.get("--revision")) } : {}),
+        ...(flags.has("--run") ? { runId: flags.get("--run") } : {}),
+        ...(flags.has("--retry-of") ? { retryOf: flags.get("--retry-of") } : {}),
+        ...(command === "run" ? { trigger: { source: flags.has("--retry-of") ? "retry" : "manual", key: requestId } } : {})
+    };
+    const result = await callFileTaskController(options.home, "job.definition", params, { environment: options.environment });
+    return `${JSON.stringify(result, null, 2)}\n`;
+}
 async function startJob(args, options) {
     const parsed = parseStartArgs(args);
     await ensureFileTaskController(options.home, { environment: options.environment });

package/dist/commands/projectCommands.js

@@ -1,12 +1,13 @@
 import { existsSync } from "node:fs";
 import { readdir, rename, rm } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-import { CliError, usageError } from "../errors/cliError.js";
+import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { boundedDocument, readOptions, recordPage } from "../output/boundedRead.js";
 import { healCheckoutSwap, restoreCheckoutSwap, swapManagedCheckout } from "../repository/checkoutSwap.js";
-import { GitWorkspaceRefreshError, NodeGitWorkspace } from "../repository/gitWorkspace.js";
+import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
 import { acquireProjectMaintenanceLock } from "../repository/projectMaintenanceLock.js";
+import { refreshRegisteredProject } from "../repository/projectRefresh.js";
 import { addProjectKnowledge, addKnowledgeProposal, assertProjectActive, decideKnowledgeProposal, createProject, findKnowledgeProposal, findKnowledgeProposalByFingerprint, knowledgeEvidenceDigest, knowledgeProposalFingerprint, managedProjectPath, planKnowledgeAcceptance, retireProject, retireProjectKnowledge, resolveProject, updateProjectKnowledge, updateProjectMetadata, validateProject, validateProjectName } from "../repository/project.js";
 import { managedWorkspacesRoot } from "../storage/homeLayout.js";
 import { projectActor } from "../task/taskAuthority.js";
@@ -90,37 +91,7 @@ async function refreshProject(args, store, options) {
         throw usageError("Project refresh usage: yui project refresh <project>.");
     }
     const project = requireProject(store, args[0]);
-    assertProjectActive(project, "refresh");
-    if (project.remoteUrl === undefined) {
-        throw usageError(`Project refresh requires a remote URL: ${project.id}.`);
-    }
-    if (project.stableBranch !== project.developmentBranch) {
-        throw usageError(`Project refresh requires matching stable and development branches: ${project.id}.`);
-    }
-    // RFC Phase 1: hold the per-Project maintenance fence for the whole refresh
-    // so Task workspace preparation and other maintenance cannot interleave
-    // with the canonical branch/working-tree move.
-    const releaseMaintenance = await acquireProjectMaintenanceLock(store.rootDirectory(), project.id, { signal: options.signal });
-    try {
-        const current = requireUnchangedMaintenanceProject(store, project, "refresh");
-        const refreshed = await (options.git ?? new NodeGitWorkspace()).refresh({
-            repositoryPath: current.path,
-            remoteUrl: current.remoteUrl,
-            stableRef: current.stableBranch
-        });
-        return { project: current, ...refreshed };
-    }
-    catch (error) {
-        if (error instanceof GitWorkspaceRefreshError) {
-            throw new CliError("RUNTIME_ERROR", error.message, undefined, {
-                projectId: project.id, refresh: error.result
-            });
-        }
-        throw error;
-    }
-    finally {
-        releaseMaintenance();
-    }
+    return refreshRegisteredProject(store, project.id, options);
 }
 /**
  * RFC Phase 1: diagnose a managed Project's divergence without mutating it.

package/dist/commands/scheduleCommands.js

@@ -0,0 +1,45 @@
+import { usageError } from "../errors/cliError.js";
+import { callFileTaskController } from "../controller/clientRuntime.js";
+import { resolveJobCaller } from "../task/taskAuthority.js";
+export async function runScheduleCommand(args, options) {
+    const [op, ...rest] = args;
+    if (op === undefined || !["create", "list", "show", "update", "enable", "disable"].includes(op)) {
+        throw usageError("Schedule command must be create, list, show, update, enable, or disable.");
+    }
+    const flags = new Map();
+    for (let i = 0; i < rest.length; i++) {
+        const flag = rest[i];
+        if (!["--global", "--task", "--schedule", "--job", "--rule", "--revision"].includes(flag) || flags.has(flag)) {
+            throw usageError(`Unknown or repeated Schedule flag: ${flag}.`);
+        }
+        if (flag === "--global") {
+            flags.set(flag, "true");
+            continue;
+        }
+        const value = rest[++i];
+        if (value === undefined || value.startsWith("--"))
+            throw usageError(`Missing value: ${flag}.`);
+        flags.set(flag, value);
+    }
+    if (flags.has("--global") === flags.has("--task"))
+        throw usageError("Choose exactly one of --global or --task.");
+    const taskId = flags.get("--task");
+    let rule;
+    if (flags.has("--rule")) {
+        try {
+            rule = JSON.parse(flags.get("--rule"));
+        }
+        catch {
+            throw usageError("--rule must be JSON.");
+        }
+    }
+    const result = await callFileTaskController(options.home, "schedule.control", {
+        op, scope: taskId === undefined ? { kind: "global" } : { kind: "task", taskId },
+        caller: resolveJobCaller(options.environment, taskId ?? ""),
+        ...(flags.has("--schedule") ? { id: flags.get("--schedule") } : {}),
+        ...(flags.has("--job") ? { jobId: flags.get("--job") } : {}),
+        ...(rule === undefined ? {} : { rule }),
+        ...(flags.has("--revision") ? { expectedRevision: Number(flags.get("--revision")) } : {})
+    }, { environment: options.environment });
+    return result;
+}

package/dist/commands/taskActivationCommands.js

@@ -6,6 +6,7 @@ import { currentManagedRuntime } from "../runtime/managedCaller.js";
 import { describeEnvironmentPlan } from "../task/taskActivation.js";
 import { cancelTaskActivation, requestTaskActivation, taskActivationOperationRef } from "../task/taskActivationService.js";
 import { taskLocalActor } from "../task/taskAuthority.js";
+import { taskPhase } from "../context/taskPhase.js";
 /**
  * Explicit Activation requests.
  *
@@ -20,7 +21,7 @@ export function runTaskActivationCommand(args, store, options) {
     switch (command) {
         case "request": return requestActivation(rest, store, options);
         case "cancel": return cancelActivation(rest, store, options);
-        case "show": return showActivation(rest, store);
+        case "show": return store.readTransaction((reader) => showActivation(rest, reader));
         default:
             throw usageError(command === undefined
                 ? "Task activation command is required."
@@ -28,7 +29,8 @@ export function runTaskActivationCommand(args, store, options) {
     }
 }
 const REQUEST_USAGE = "Task activation request usage: yui task activation request <task> "
-    + "--request-id <id> --environment <empty|scratch|local:<resource>:<read|write>>.";
+    + "--request-id <id> --environment <empty|scratch|local:<resource>:<read|write>> "
+    + "[--source-message <message-id> | --source-text <exact-input>].";
 /**
  * Records the request and returns its reference immediately.
  *
@@ -39,19 +41,26 @@ const REQUEST_USAGE = "Task activation request usage: yui task activation reques
  * current then.
  */
 function requestActivation(args, store, options) {
-    const parsed = parseTail(args, new Set(["--request-id", "--environment"]), REQUEST_USAGE);
+    const parsed = parseTail(args, new Set(["--request-id", "--environment", "--source-message", "--source-text"]), REQUEST_USAGE);
     exactPositionals(parsed.positionals, 1, REQUEST_USAGE);
     const taskId = parsed.positionals[0];
     const requestId = requiredOption(parsed.options, "--request-id", REQUEST_USAGE);
     const environmentPlan = parseEnvironmentPlan(requiredOption(parsed.options, "--environment", REQUEST_USAGE), REQUEST_USAGE);
     const now = options.now?.() ?? new Date();
     const caller = activationCaller(store, options, taskId);
+    const sourceMessageId = parsed.options.get("--source-message");
+    const sourceText = parsed.options.get("--source-text");
+    if (caller.actorId.startsWith("task:") && sourceMessageId === undefined && sourceText === undefined) {
+        throw usageError("Leader activation requires --source-message or --source-text with the exact new user input. Read the original; do not substitute a Brief summary.", REQUEST_USAGE);
+    }
     const result = attempt(REQUEST_USAGE, () => requestTaskActivation(store, {
         taskId,
         requestId,
         actorId: caller.actorId,
         authorityRef: caller.authorityRef,
         environmentPlan,
+        sourceMessageId, sourceText,
+        sourceNativeSessionId: caller.nativeSessionId,
         ...(caller.planningRunId === undefined ? {} : { callerRunId: caller.planningRunId })
     }, now));
     // An immediate request has nothing left to wait for, so ask the Controller to
@@ -64,12 +73,14 @@ function requestActivation(args, store, options) {
         void options.runtime?.notifyMailboxChanged({ kind: "task", taskId });
     }
     const request = result.request;
+    const source = taskPhase(store, { ...requireTask(store, taskId), activationRequest: request }).activation?.source;
     const lines = [
         `${result.created ? "Requested" : "Existing"} activation ${result.operationRef}`,
         `Task: ${taskId} (draft)`,
         `Start: ${result.startMode}${result.afterPlanningRun === undefined ? "" : ` after ${taskId}/${result.afterPlanningRun}`}`,
         `Environment: ${describeEnvironmentPlan(request.environmentPlan)}`,
         `Disposition: ${request.disposition}`,
+        ...(source?.read === undefined ? [] : [`Source: yui ${source.read}`]),
         result.startMode === "after-planning-turn"
             ? "This reference is returned now; the request is adopted after the planning Turn ends."
             : `Adopt it with: yui task activate ${taskId}`
@@ -81,7 +92,8 @@ function requestActivation(args, store, options) {
         ...(result.afterPlanningRun === undefined
             ? {}
             : { afterPlanningRun: result.afterPlanningRun }),
-        request
+        request,
+        source
     });
 }
 /** A cancelled request is never adopted, even if the same id is retried. */
@@ -139,7 +151,8 @@ function showActivation(args, store) {
         `Requested at: ${request.requestedAt}`,
         ...settledLines
     ];
-    return output(`${lines.join("\n")}\n`, { task, request, settledRequests: settled });
+    return output(`${lines.join("\n")}\n`, { task, request, settledRequests: settled,
+        phase: taskPhase(store, task) });
 }
 /**
  * Resolves who is requesting, and whether they are running inside this Task's
@@ -161,6 +174,7 @@ function activationCaller(store, options, taskId) {
             : store.getRun(taskId, runtime.currentRunId);
         return {
             actorId: `task:${taskId}/role:${SYSTEM_LEADER_ROLE}`,
+            nativeSessionId: runtime.nativeSessionId,
             // Non-secret binding fingerprint of the live Session, matching the Job
             // boundary: reattaching the same Session keeps it, replacing it does not.
             authorityRef: fingerprint([

package/dist/commands/taskCommands.js

@@ -665,6 +665,7 @@ function routeUserSubmission(tx, task, actor, body, intent, now, submissionKey,
                 requestId: `submit-${message.id}`,
                 actorId: identity.actorId,
                 authorityRef: identity.authorityRef,
+                sourceMessageId: message.id,
                 environmentPlan: routing.environmentPlan
             }, now);
             activationRef = taskActivationOperationRef(task.id, `submit-${message.id}`);
@@ -7008,7 +7009,7 @@ function taskWakeInspectionCommand(args, store) {
         const windowEvents = allEvents.filter((e) => inWindow(e.createdAt) || referenced("event", e.id) || reasonEvent(e));
         const events = history ? windowEvents : windowEvents.filter(e => referenced("event", e.id)
             || reasonEvent(e) || ["run.completed", "run.failed", "run.cancelled"].includes(e.type));
-        const messages = wakeMessages(wake, store.listMessages(task.id));
+        const messages = wakeMessages(wake, store.listMessages(task.id), history);
         const allRuns = store.listRuns(task.id);
         const referencedRunIds = new Set(referencedWakeRunIds(allRuns, allEvents, events));
         for (const run of allRuns)

package/dist/commands/taskFactCommands.js

@@ -1,5 +1,5 @@
 import { createTaskBrief, updateTaskBrief } from "../brief/taskBrief.js";
-import { assertContextRecordReadable } from "../context/taskContext.js";
+import { assertContextRecordReadable, resolveContextReader } from "../context/taskContext.js";
 import { taskRecordList } from "./taskContextCommand.js";
 import { materialize } from "../context/taskContext.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
@@ -8,15 +8,22 @@ import { dataError, usageError } from "../errors/cliError.js";
 import { createMilestone } from "../milestone/milestone.js";
 import { assertTaskOpen, clock, exactPositionals, leaderActionEventPayload, leaderMailbox, notifyMailbox, output, parseMultiValueTail, parseTail, presentTime, recordTaskEvent, requiredOption, requiredText, requireTask, taskActor, taskMailbox, taskRef } from "./taskCommandSupport.js";
 import { failureCapabilitiesCommand } from "../runtime/agentFailureContext.js";
+import { taskBriefGuard, taskPhase } from "../context/taskPhase.js";
 export function taskBriefCommand(args, store, options) {
     const [command, ...rest] = args;
     if (command === "show") {
         exactPositionals(rest, 1, "Task brief show usage: yui task brief show <task>.");
-        const task = requireTask(store, rest[0]);
-        assertContextRecordReadable(store, task.id, "task-brief", task.id, options.environment);
-        const brief = store.getTaskBrief(task.id);
+        const { task, brief, writeGuard, phase } = store.readTransaction(reader => {
+            const task = requireTask(reader, rest[0]);
+            assertContextRecordReadable(reader, task.id, "task-brief", task.id, options.environment);
+            const caller = resolveContextReader(reader, options.environment ?? {});
+            const shared = caller === undefined || caller.roleName === "leader";
+            return { task, brief: reader.getTaskBrief(task.id),
+                writeGuard: shared ? taskBriefGuard(reader, task) : undefined,
+                phase: shared ? taskPhase(reader, task) : undefined };
+        });
         if (brief === null) {
-            return output(`Task ${task.id} has no brief.\n`, { taskId: task.id, brief: null });
+            return output(`Task ${task.id} has no brief.\n${writeGuard === undefined ? "" : `Write guard: ${writeGuard}\n`}`, { taskId: task.id, brief: null, writeGuard, phase });
         }
         const timeZone = store.getConfig().timeZone;
         const working = task.status === "draft" || task.status === "active";
@@ -32,12 +39,13 @@ export function taskBriefCommand(args, store, options) {
             `${working ? "Current focus" : "Last working focus"}: ${brief.currentFocus}`,
             `${working ? "Leader summary" : "Last working summary"}: ${brief.leaderSummary}`,
             `Updated by: ${brief.updatedBy}`,
-            `Updated at: ${presentTime(brief.updatedAt, timeZone)}`
-        ].join("\n").concat("\n"), { taskId: task.id, brief });
+            `Updated at: ${presentTime(brief.updatedAt, timeZone)}`,
+            ...(writeGuard === undefined ? [] : [`Write guard: ${writeGuard}`])
+        ].join("\n").concat("\n"), { taskId: task.id, brief, writeGuard, phase });
     }
     if (command === "update") {
-        const usage = "Task brief update usage: yui task brief update <task> [--objective <text>] [--boundary <text> ...] [--approach <text>] [--focus <text>] [--leader-summary <text>].";
-        const parsed = parseMultiValueTail(rest, new Set(["--objective", "--approach", "--focus", "--leader-summary"]), new Set(["--boundary"]), usage);
+        const usage = "Task brief update usage: yui task brief update <task> --if-current <writeGuard> [--objective <text>] [--boundary <text> ...] [--approach <text>] [--focus <text>] [--leader-summary <text>].";
+        const parsed = parseMultiValueTail(rest, new Set(["--objective", "--approach", "--focus", "--leader-summary", "--if-current"]), new Set(["--boundary"]), usage);
         exactPositionals(parsed.positionals, 1, usage);
         const hasObjective = parsed.options.has("--objective");
         const hasApproach = parsed.options.has("--approach");
@@ -53,6 +61,9 @@ export function taskBriefCommand(args, store, options) {
             assertTaskOpen(task);
             const existing = tx.getTaskBrief(task.id);
             const updatedBy = taskActor(tx, options, task.id);
+            if (parsed.options.get("--if-current") !== taskBriefGuard(tx, task)) {
+                throw usageError(`Task context or Brief changed, or --if-current is missing; read task brief show ${task.id}, reconcile new input, then retry with its writeGuard.`);
+            }
             const brief = existing === null
                 ? createTaskBrief({
                     objective: requiredText(parsed.options.get("--objective"), "--objective"),
@@ -244,9 +255,10 @@ export function taskEventCommand(args, store, options = {}) {
         exactPositionals(rest, 2, "Task event show usage: yui task event show <task> <event>.");
         const task = requireTask(store, rest[0]);
         assertContextRecordReadable(store, task.id, "task-event", rest[1], options.environment);
-        const events = store.listEvents(task.id);
-        const event = events.find((e) => e.id === rest[1]) ?? null;
-        if (event === null)
+        const event = store.queryContextRecords(task.id, {
+            family: "task-event", ids: [rest[1]], limit: 1
+        }).records[0]?.value;
+        if (event === undefined)
             throw dataError(`Event not found: ${rest[1]}.`);
         const timeZone = store.getConfig().timeZone;
         const capabilitiesCommand = event.type === "runtime.agent-error" && event.payload.roleName

package/dist/commands/taskPublicationCommands.js

@@ -35,7 +35,7 @@ export function runPublicationCommand(args, store, options) {
     }
 }
 function upsertPublication(args, store, options) {
-    const usage = "Task publication upsert usage: yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--head-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported|--verified] [--evidence <text>] [--merged-at <iso-timestamp>].";
+    const usage = "Task publication upsert usage: yui task publication upsert <task> --project <project> --provider <github|gitlab> --repository <owner/name> --kind <pull-request|merge-request> --id <external-id> [--url <url>] [--title <text>] [--source-branch <branch>] [--target-branch <branch>] [--local-commit <sha>] [--head-commit <sha>] [--remote-commit <sha>] [--state <open|merged|closed>] [--reported] [--evidence <text>] [--merged-at <iso-timestamp>].";
     const parsed = parseUpsertArgs(args, usage);
     exactPositionals(parsed.positionals, 1, usage);
     const task = requireTask(store, parsed.positionals[0]);
@@ -173,8 +173,9 @@ function parseVerification(parsed, usage) {
     if (parsed.flags.has("--reported") && parsed.flags.has("--verified")) {
         throw usageError("--reported and --verified are mutually exclusive.", usage);
     }
-    if (parsed.flags.has("--verified"))
-        return "verified";
+    if (parsed.flags.has("--verified")) {
+        throw usageError("Use task publication verify with a provider read or --observation tool evidence; upsert cannot assert --verified.");
+    }
     if (parsed.flags.has("--reported"))
         return "reported";
     return undefined;
@@ -210,6 +211,8 @@ function inheritPublicationInput(existing, input) {
             && normalizeCommitForComparison(input.headCommit) !== existing.headCommit)
         || input.projectId !== existing.projectId
         || input.externalKind !== existing.externalKind
+        || (input.externalUrl !== undefined && input.externalUrl !== existing.externalUrl)
+        || (input.targetBranch !== undefined && input.targetBranch !== existing.targetBranch)
         || stateChanged
         || remoteCommitChanged
         || evidenceChanged