@zq-silk/yui 0.15.8 → 0.15.9

package/dist/cli.js

@@ -46,6 +46,7 @@ import { runTaskPublicationVerifyCommand } from "./commands/taskPublicationVerif
 import { createGitHubCliPublicationVerifier } from "./external/githubPublicationVerifier.js";
 import { createGitLabCliPublicationVerifier } from "./external/gitlabPublicationVerifier.js";
 import { taskLocalActor, assertTaskDeliveryAuthority } from "./commands/taskActor.js";
+import { saveArtifactCapability, readArtifactCapability, listArtifactsCapability } from "./artifacts/artifactCapability.js";
 import { parseTaskExecutionStartRequest, parseTaskExecutionStopRequest, finalizeStoppedTaskExecution, startTaskExecutionCommand, stopTaskExecutionCommand } from "./commands/taskExecutionCommands.js";
 import { runTaskIntegrationCommand } from "./commands/taskIntegrationCommands.js";
 import { runTaskChangeSetCommand } from "./commands/taskChangeSetCommands.js";
@@ -773,6 +774,72 @@ export async function main() {
         return;
     }
     if (resolved[0] === "task") {
+        if (resolved[1] === "artifact") {
+            // File/directory artifacts live in the Task's local Git repository, so
+            // their save/read/list are asynchronous and handled here rather than in
+            // the synchronous runTaskCommand chain. Save commits exactly one path and
+            // returns a self-certifying commit-pinned reference; read pins to a commit
+            // for frozen evidence; list is an ordinary current read.
+            const action = resolved[2];
+            const taskId = resolved[3];
+            const usage = "Usage: yui task artifact list <task> | read <task> <relative-path> [<commit>] | "
+                + "save <task> <relative-path> <content> [--message <text>] [--expected-head <commit>]";
+            if (taskId === undefined || action === undefined || !["list", "read", "save"].includes(action)) {
+                throw usageError(usage);
+            }
+            if (process.env.YUI_SESSION_SCOPE === "task" && process.env.YUI_TASK_ID !== taskId) {
+                throw usageError("Artifact is outside the managed Task scope.");
+            }
+            if (store.getTask(taskId) === null)
+                throw usageError(`Task not found: ${taskId}.`);
+            let data;
+            if (action === "list") {
+                if (resolved.length !== 4)
+                    throw usageError(usage);
+                data = await listArtifactsCapability(home, taskId);
+            }
+            else if (action === "read") {
+                const relativePath = resolved[4];
+                const commit = resolved[5];
+                if (relativePath === undefined || resolved.length > 6)
+                    throw usageError(usage);
+                data = await readArtifactCapability(home, taskId, {
+                    relativePath, ...(commit === undefined ? {} : { commit })
+                });
+            }
+            else {
+                // save: a delivery-authoritative action; a managed Task caller must be the current Leader.
+                taskLocalActor(store, process.env, taskId);
+                const relativePath = resolved[4];
+                const content = resolved[5];
+                if (relativePath === undefined || content === undefined)
+                    throw usageError(usage);
+                const rest = resolved.slice(6);
+                let message;
+                let expectedHead;
+                for (let index = 0; index < rest.length; index += 1) {
+                    const value = rest[index + 1];
+                    if (rest[index] === "--message" && value !== undefined) {
+                        message = value;
+                        index += 1;
+                        continue;
+                    }
+                    if (rest[index] === "--expected-head" && value !== undefined) {
+                        expectedHead = value;
+                        index += 1;
+                        continue;
+                    }
+                    throw usageError(usage);
+                }
+                data = await saveArtifactCapability(home, taskId, {
+                    relativePath, content,
+                    ...(message === undefined ? {} : { message }),
+                    ...(expectedHead === undefined ? {} : { expectedHead })
+                });
+            }
+            emit(JSON.stringify(data, null, 2), false, data);
+            return;
+        }
         if (resolved[1] === "execution") {
             if (resolved[2] === "stop") {
                 const request = parseTaskExecutionStopRequest(resolved.slice(3));

package/dist/commands/operatorCommands.js

@@ -5,6 +5,7 @@ import { listOperatorSessions, projectOperatorStatus, prepareOperatorNewSession,
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { formatRelativeTimestamp } from "../output/timePresentation.js";
 import { updateGlobalRole } from "../role/role.js";
+import { TASK_SUBMISSION_INTENTS } from "../message/message.js";
 import { submitOperatorMessage } from "./taskCommands.js";
 import { readCommandText } from "./textInput.js";
 /** Operator command parsing never launches or attaches a native process. */
@@ -63,10 +64,12 @@ function status(args, store, options) {
     };
 }
 function submit(rest, store, options) {
-    const usage = "Operator submit usage: yui operator submit (<body>|--body-file <path|->) [--task <id>].";
+    const usage = "Operator submit usage: yui operator submit (<body>|--body-file <path|->) [--task <id>] [--intent record|discuss|develop] [--request-id <key>].";
     const positionals = [];
     let taskId;
     let bodyFile;
+    let intentRaw;
+    let requestId;
     for (let index = 0; index < rest.length; index += 1) {
         const value = rest[index];
         if (value === "--body-file") {
@@ -79,6 +82,26 @@ function submit(rest, store, options) {
             index += 1;
             continue;
         }
+        if (value === "--intent") {
+            if (intentRaw !== undefined)
+                throw usageError("Option may only be specified once: --intent.", usage);
+            const candidate = rest[index + 1];
+            if (candidate === undefined || candidate.startsWith("--"))
+                throw usageError("--intent is required.", usage);
+            intentRaw = candidate.trim();
+            index += 1;
+            continue;
+        }
+        if (value === "--request-id") {
+            if (requestId !== undefined)
+                throw usageError("Option may only be specified once: --request-id.", usage);
+            const candidate = rest[index + 1];
+            if (candidate === undefined || candidate.startsWith("--"))
+                throw usageError("--request-id is required.", usage);
+            requestId = candidate.trim();
+            index += 1;
+            continue;
+        }
         if (value !== "--task") {
             if (value.startsWith("--"))
                 throw usageError(`Unsupported option: ${value}.`, usage);
@@ -96,10 +119,18 @@ function submit(rest, store, options) {
     }
     if (positionals.length > 1)
         throw usageError(usage);
+    const intent = intentRaw === undefined
+        ? undefined
+        : TASK_SUBMISSION_INTENTS.includes(intentRaw)
+            ? intentRaw
+            : (() => { throw usageError(`--intent must be one of ${TASK_SUBMISSION_INTENTS.join(", ")}: ${intentRaw}.`, usage); })();
+    if (requestId !== undefined && requestId.length === 0) {
+        throw usageError("--request-id is required.", usage);
+    }
     const body = readCommandText(positionals[0], bodyFile, "--body", usage);
     return {
         kind: "output",
-        output: submitOperatorMessage(body, taskId, store, options)
+        output: submitOperatorMessage(body, taskId, store, options, intent, requestId)
     };
 }
 function listSessions(args, store, options) {

package/dist/commands/taskActivationCommands.js

@@ -52,6 +52,10 @@ function requestActivation(args, store, options) {
         actorId: caller.actorId,
         authorityRef: caller.authorityRef,
         environmentPlan,
+        // The activation-request command is the explicit activation boundary, so
+        // every request it records carries an explicit provable origin (task-32
+        // §2.4). A develop submission records its own request with `submit-develop`.
+        origin: "explicit",
         ...(caller.planningRunId === undefined ? {} : { callerRunId: caller.planningRunId })
     }, now));
     // An immediate request has nothing left to wait for, so ask the Controller to
@@ -173,6 +177,24 @@ function activationCaller(store, options, taskId) {
                 : {})
         };
     }
+    if (actor === "operator") {
+        return nonLeaderActivationIdentity(store, "operator");
+    }
+    return nonLeaderActivationIdentity(store, "user");
+}
+/**
+ * The activation actor/authority identity for a user or Operator submission.
+ *
+ * A develop submission (task-32 §2.4) records its own activation request inside
+ * the message-save transaction, and it must stamp the exact same identity the
+ * explicit `yui task activation request` boundary would for the same caller —
+ * otherwise the Controller and the workspace preparer could treat "the user
+ * asked via submit" differently from "the user asked via activate". Sharing this
+ * mapping is what keeps the two entry points one activation contract rather than
+ * two. Leader identity is deliberately excluded: it binds to a live native
+ * Session and is resolved only by {@link activationCaller}.
+ */
+export function nonLeaderActivationIdentity(store, actor) {
     if (actor === "operator") {
         return {
             actorId: "global:operator",