@zq-silk/yui 0.15.8 → 0.15.9

package/dist/context/runContextPack.js

@@ -3,7 +3,7 @@ import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publica
 import { RUN_INPUT_MAX_DELTAS } from "./runInputContract.js";
 import { assertWorkItemDependenciesCompleted } from "../workItem/dependencyGate.js";
 import { governingWorkItemCandidate, workItemExecutionGroupById } from "../workItem/workItem.js";
-import { stableArtifactRef } from "../resources/projectResource.js";
+import { formatGitArtifactRef, validateGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot, validateContextSnapshot } from "./contextSnapshot.js";
 import { MAX_SYNTHESIS_SOURCE_RUNS, sourceRunContextValue } from "./sourceRunContext.js";
@@ -99,14 +99,14 @@ export function freezeWorkItemExecutionAssignmentContextSnapshot(store, input, n
         materialize("L2", "task", task.id, task),
         materialize("L3", "work-item", workItem.id, workItem)
     ];
-    materialized.push(...candidateArtifacts(store, task.id, workItem.candidates));
+    materialized.push(...candidateArtifacts(task.id, workItem.candidates));
     assertWorkItemDependenciesCompleted(store, workItem);
     for (const dependencyId of workItem.dependsOn) {
         const dependency = store.getWorkItem(task.id, dependencyId);
         if (dependency === null)
             throw new Error(`WorkItem dependency disappeared: ${dependencyId}.`);
         materialized.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
-        materialized.push(...candidateArtifacts(store, task.id, dependency.candidates));
+        materialized.push(...candidateArtifacts(task.id, dependency.candidates));
     }
     for (const binding of task.projectBindings) {
         const project = store.getProject(binding.projectId);
@@ -371,7 +371,7 @@ function collectAuthorizedContext(store, run) {
         if (item === null)
             throw new Error(`AgentRun WorkItem not found: ${run.workItemId}.`);
         result.push(materialize("L3", "work-item", item.id, item));
-        result.push(...candidateArtifacts(store, task.id, item.candidates));
+        result.push(...candidateArtifacts(task.id, item.candidates));
         if (view === "worker") {
             assertWorkItemDependenciesCompleted(store, item);
             for (const dependencyId of item.dependsOn) {
@@ -379,7 +379,7 @@ function collectAuthorizedContext(store, run) {
                 if (dependency === null)
                     throw new Error(`WorkItem dependency disappeared: ${dependencyId}.`);
                 result.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
-                result.push(...candidateArtifacts(store, task.id, dependency.candidates));
+                result.push(...candidateArtifacts(task.id, dependency.candidates));
             }
         }
     }
@@ -394,7 +394,7 @@ function collectAuthorizedContext(store, run) {
                 if (candidate === undefined)
                     continue;
                 result.push(materialize("L3", "candidate", `${item.id}/${candidate.id}`, candidate));
-                result.push(...candidateArtifacts(store, task.id, [candidate]));
+                result.push(...candidateArtifacts(task.id, [candidate]));
             }
         }
         if (round.deltaRecheck !== undefined) {
@@ -425,9 +425,12 @@ function collectAuthorizedContext(store, run) {
         }
     }
     if (view === "leader") {
-        for (const artifact of store.listArtifacts(task.id)) {
-            result.push(materialize("L3", "artifact", artifact.id, artifact));
-        }
+        // File artifacts are NOT enumerated into the synchronous context pack: the
+        // core cursor does not cover file edits, and an ambient directory listing
+        // here would be exactly the forbidden update-time mirror (§3.7). The Leader
+        // reads current artifacts on demand via the async `artifact.list` /
+        // `artifact.read` capabilities; frozen Candidate artifacts still enter the
+        // pack as commit-pinned pointers through candidateArtifacts().
         for (const preparation of store.listEnvironmentPreparations(task.id)) {
             result.push(materialize("L3", "environment-preparation", preparation.id, preparation));
         }
@@ -476,16 +479,25 @@ function collectAuthorizedContext(store, run) {
     return [...unique.values()].sort((left, right) => (contextRefIdentity(left.ref).localeCompare(contextRefIdentity(right.ref))));
 }
 /** Only artifacts attached to already-authorized candidates enter a bounded
- * Worker/Reviewer snapshot. Their immutable Home content survives cleanup of
+ * Worker/Reviewer snapshot. Each is a commit-pinned pointer: the commit
+ * self-certifies the frozen bytes, so the pointer is carried as pure data with
+ * NO build-time Git read. The bytes are resolved lazily on the async expand
+ * path (`artifact.read` at the pinned commit); the pointer survives cleanup of
  * the producing workspace and Session. */
-function candidateArtifacts(store, taskId, candidates) {
+function candidateArtifacts(taskId, candidates) {
     return candidates.flatMap((candidate) => (candidate.artifactRefs ?? []).map((ref) => {
-        const artifact = ref.taskId === taskId ? store.getArtifact(taskId, ref.artifactId) : null;
-        const actual = artifact === null ? null : stableArtifactRef(artifact);
-        if (artifact === null || actual?.kind !== ref.kind || actual.digest !== ref.digest) {
-            throw new Error(`Candidate Artifact is unavailable or drifted: ${ref.artifactId}.`);
+        const pinned = validateGitArtifactRef(ref);
+        if (pinned.taskId !== taskId) {
+            throw new Error(`Candidate Artifact belongs to another Task: ${pinned.taskId}.`);
         }
-        return materialize("L3", "artifact", artifact.id, artifact);
+        // The refId is the self-certifying string form; the value is the pure
+        // pointer, never the bytes. inspectValue reconstructs the same pointer.
+        return materialize("L3", "artifact", formatGitArtifactRef(pinned), {
+            taskId: pinned.taskId,
+            commit: pinned.commit,
+            relativePath: pinned.relativePath,
+            ...(pinned.digest === undefined ? {} : { digest: pinned.digest })
+        });
     }));
 }
 /** Lane-specific context that may be layered over an immutable stage base. */

package/dist/context/taskContext.js

@@ -6,6 +6,7 @@ import { sourceRunContextValue } from "./sourceRunContext.js";
 import { expandTaskMessageResult } from "../message/message.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { runExecutionObservation } from "../agentRun/agentRun.js";
+import { isGitArtifactRefString, parseGitArtifactRef } from "../artifacts/gitArtifactRef.js";
 const MAX_RECORDS = 256;
 const MAX_VALUE_BYTES = 4096;
 const MAX_PAGE_BYTES = 128 * 1024;
@@ -302,7 +303,26 @@ function inspectValue(store, { task, allow, caller }, { store: family, refId })
             return run === null ? null : sourceRunContextValue(run);
         }
         case "review-round": return store.getReviewRound(taskId, refId);
-        case "artifact": return store.getArtifact(taskId, refId);
+        case "artifact": {
+            // A file artifact is addressed by its self-certifying commit-pinned refId
+            // (git:<commit>:<relativePath>). Resolve it to the pure pointer only; the
+            // bytes are read on the async `artifact.read` path, never synchronously in
+            // this transaction.
+            if (!isGitArtifactRefString(refId))
+                return null;
+            try {
+                const pinned = parseGitArtifactRef(refId, taskId);
+                return {
+                    taskId: pinned.taskId,
+                    commit: pinned.commit,
+                    relativePath: pinned.relativePath,
+                    ...(pinned.digest === undefined ? {} : { digest: pinned.digest })
+                };
+            }
+            catch {
+                return null;
+            }
+        }
         case "environment-preparation": return store.getEnvironmentPreparation(taskId, refId);
         case "change-set": return store.getChangeSet(taskId, refId);
         case "managed-workspace": {
@@ -365,8 +385,11 @@ function authorizedEntries(store, taskId, environment) {
         for (const candidate of [...item.candidates].reverse())
             add("candidate", `${item.id}/${candidate.id}`, candidate);
     }
-    for (const artifact of store.listArtifacts(taskId))
-        add("artifact", artifact.id, artifact);
+    // File artifacts are not enumerated into the synchronous Context listing: the
+    // core cursor does not cover file edits and an ambient directory index here
+    // would be the forbidden update-time mirror (§3.7). Current artifacts are
+    // listed on demand via the async `artifact.list` capability; frozen Candidate
+    // artifacts remain reachable as commit-pinned pointers under their Candidate.
     for (const preparation of store.listEnvironmentPreparations(taskId))
         add("environment-preparation", preparation.id, preparation);
     for (const workspace of store.listManagedWorkspaces(taskId))

package/dist/controller/controller.js

@@ -16,6 +16,7 @@ import { nearestDeadlineBatch } from "../coordination/deadlineScheduler.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 import { hasRuntimeCleanupObligation } from "../runtime/lifecycleReservation.js";
 import { formatTaskRecordReference } from "../task/taskRecordReference.js";
+import { activationRequestIsControllerAdoptable } from "../task/taskActivation.js";
 import { parseDurableJobAcknowledgeParams, parseDurableJobCancelParams, parseDurableJobRefParams, parseDurableJobStartParams } from "./jobControl.js";
 const DEFAULT_RECONCILIATION_INTERVAL_MS = reconciliationIntervalMilliseconds();
 const DEFAULT_SIGNAL_WINDOW_MS = 100;
@@ -488,8 +489,13 @@ async function adoptReleasedTaskActivations(store, workspace, selection, onError
         const request = task.activationRequest;
         if (request?.disposition !== "pending")
             continue;
-        if (request.startMode !== "after-planning-turn"
-            && request.operation.actorId !== `task:${taskId}/role:leader`)
+        // Continue only requests with a provable source: a released deferral, or an
+        // immediate request carrying a recognised origin (explicit action, or a
+        // develop submission accepted while unplanned). This admits legal
+        // Operator/user immediate requests the old actor filter dropped, while
+        // still refusing origin-less historical requests, which stay behind the
+        // explicit `yui task activate` boundary.
+        if (!activationRequestIsControllerAdoptable(request))
             continue;
         // Later Draft discussion is a Session notification, not another AgentRun.
         // Its durable activation intent is sufficient once the exact native input

package/dist/kernel/builtinCapabilities.js

@@ -6,7 +6,7 @@ import { createJobCallAuthority, parseDurableJobStartParams } from "../controlle
 import { inspectJobOperation } from "./kernelPorts.js";
 import { CapabilityRegistry, } from "./capabilityRegistry.js";
 import { createProjectResources } from "../resources/projectResourceService.js";
-import { artifactSummary } from "../resources/projectResource.js";
+import { saveArtifactCapability, readArtifactCapability, listArtifactsCapability } from "../artifacts/artifactCapability.js";
 import { createPluginService } from "../plugins/pluginService.js";
 const text = { type: "string", minLength: 1 };
 const strings = { type: "object", additionalProperties: { type: "string" } };
@@ -15,7 +15,6 @@ const object = (properties, required = Object.keys(properties)) => ({
 });
 const taskInput = object({ taskId: text });
 const recordOutput = { type: "object" };
-const artifactBase = { displayName: text, provenance: text, mediaType: text };
 const taskOutput = { type: "object", required: ["id", "status", "title"], properties: {
         id: text, status: text, title: text
     } };
@@ -26,6 +25,7 @@ const definitions = [
         name: "message.send", summary: "Save collaboration for Leader or continue the same dispatched work owner.",
         effect: "local-mutation", requiredPermissions: ["task:read"], source: "sendTaskMessageCommand",
         inputSchema: object({ taskId: text, body: text,
+            intent: { enum: ["record", "discuss", "develop"] },
             wakePolicy: { enum: ["leader", "none"] },
             recipient: object({ roleName: text, workItemId: text, reviewRoundId: text }, ["roleName"])
         }, ["taskId", "body"]), outputSchema: recordOutput
@@ -48,23 +48,20 @@ const definitions = [
         outputSchema: { type: "object", required: ["ref", "value", "coreCursor"] }
     },
     {
-        name: "artifact.save", summary: "Save immutable text, external version evidence, a Job receipt, or reference material.",
-        effect: "local-mutation", requiredPermissions: ["task:read"], source: "ProjectResources.saveArtifact",
-        inputSchema: object({ taskId: text, artifact: { anyOf: [
-                    object({ ...artifactBase, kind: { const: "content" }, content: { type: "string" } }, ["kind", "displayName", "provenance", "content"]),
-                    object({ ...artifactBase, kind: { const: "external-version" }, resourceId: text, version: text, verification: text }, ["kind", "displayName", "provenance", "resourceId", "version", "verification"]),
-                    object({ ...artifactBase, kind: { const: "receipt" }, jobId: text, receiptRef: text }, ["kind", "displayName", "provenance", "jobId", "receiptRef"]),
-                    object({ ...artifactBase, kind: { const: "reference" }, locator: text, observedAt: text }, ["kind", "displayName", "provenance", "locator", "observedAt"])
-                ] } }), outputSchema: recordOutput
+        name: "artifact.save", summary: "Save a file artifact by relativePath into the Task's local Git repository; returns a commit-pinned reference.",
+        effect: "local-mutation", requiredPermissions: ["task:read"], source: "artifacts.saveArtifactCapability",
+        inputSchema: object({ taskId: text, relativePath: text, content: { type: "string" }, message: text, expectedHead: text }, ["taskId", "relativePath", "content"]),
+        outputSchema: { type: "object", required: ["taskId", "commit", "relativePath"] }
     },
     {
-        name: "artifact.read", summary: "Read saved results without starting the original Runtime or plugin.",
-        effect: "query", requiredPermissions: ["task:read"], source: "TaskStore.getArtifact",
-        inputSchema: object({ taskId: text, artifactId: text }), outputSchema: recordOutput
+        name: "artifact.read", summary: "Read a file artifact at HEAD, or at a pinned commit for frozen evidence, without starting a Runtime or plugin.",
+        effect: "query", requiredPermissions: ["task:read"], source: "artifacts.readArtifactCapability",
+        inputSchema: object({ taskId: text, relativePath: text, commit: text }, ["taskId", "relativePath"]),
+        outputSchema: { type: "object", required: ["taskId", "relativePath", "commit", "content"] }
     },
     {
-        name: "artifact.list", summary: "List this Task's saved results and references.",
-        effect: "query", requiredPermissions: ["task:read"], source: "TaskStore.listArtifacts",
+        name: "artifact.list", summary: "List this Task's tracked file artifacts at HEAD.",
+        effect: "query", requiredPermissions: ["task:read"], source: "artifacts.listArtifactsCapability",
         inputSchema: taskInput, outputSchema: { type: "array", items: recordOutput }
     },
     {
@@ -246,7 +243,11 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
             }
             const taskId = invocation.context.targetId;
             if (name === "message.send") {
-                const result = sendTaskMessageCommand(store, taskId, params.body, params.wakePolicy, { environment: callerEnvironment(caller) }, params.recipient);
+                // A managed Task Session resolves to Leader/role authority and never
+                // gains develop from an intent argument; only a global Operator Session
+                // (user-authority) may carry one. sendTaskMessageCommand enforces this,
+                // so the capability just forwards the optional intent unchanged.
+                const result = sendTaskMessageCommand(store, taskId, params.body, params.wakePolicy, { environment: callerEnvironment(caller) }, params.recipient, params.intent);
                 signal(taskId);
                 return result.message;
             }
@@ -279,16 +280,23 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                 return inspectTaskContext(store, taskId, {
                     store: params.store, refId: params.refId, digest: params.digest
                 }, callerEnvironment(caller));
+            // File/directory artifacts live in the Task's local Git repository, not
+            // the DB. Save commits exactly one path and returns a self-certifying
+            // commit-pinned reference; read/list are ordinary current reads. These
+            // are the async Git path (the capability layer awaits invoke()).
             if (name === "artifact.save")
-                return resources.saveArtifact(taskId, params.artifact);
-            if (name === "artifact.read") {
-                const artifact = store.getArtifact(taskId, params.artifactId);
-                if (!artifact)
-                    throw new Error("Artifact not found in this Task.");
-                return artifact;
-            }
+                return saveArtifactCapability(store.rootDirectory(), taskId, {
+                    relativePath: params.relativePath, content: params.content,
+                    ...(params.message === undefined ? {} : { message: params.message }),
+                    ...(params.expectedHead === undefined ? {} : { expectedHead: params.expectedHead })
+                });
+            if (name === "artifact.read")
+                return readArtifactCapability(store.rootDirectory(), taskId, {
+                    relativePath: params.relativePath,
+                    ...(params.commit === undefined ? {} : { commit: params.commit })
+                });
             if (name === "artifact.list")
-                return store.listArtifacts(taskId).map(artifactSummary);
+                return listArtifactsCapability(store.rootDirectory(), taskId);
             if (name === "environment.prepare")
                 return resources.prepare(taskId, params.plan);
             if (name === "environment.adopt")

package/dist/message/message.js

@@ -1,5 +1,19 @@
 import { validateTaskRecordReference } from "../task/taskRecordReference.js";
 export const TASK_MESSAGE_KINDS = ["user", "operator", "role-result", "system"];
+/**
+ * How a user/operator submission asks its Task to react (task-32 Requirement A).
+ *
+ * - `record`: save only. No Leader wake, no planning, no activation.
+ * - `discuss`: save and route to planning (the default when a submission omits
+ *   an intent, so an old client keeps its existing Leader-waking behaviour).
+ * - `develop`: save the requirement and its activation intent; an unplanned
+ *   Draft records an activation request and queues only activation processing.
+ *
+ * The intent is never inferred from body text and is only meaningful on a
+ * user/operator submission: a role-result or system Message can never carry one,
+ * so an internal Agent report cannot acquire develop authority.
+ */
+export const TASK_SUBMISSION_INTENTS = ["record", "discuss", "develop"];
 export function createTaskMessage(id, taskId, body, kind, author, now, context = {}) {
     validateKindAndAuthor(kind, author);
     const message = {
@@ -12,6 +26,12 @@ export function createTaskMessage(id, taskId, body, kind, author, now, context =
         ...(context.wakePolicy === undefined
             ? {}
             : { wakePolicy: context.wakePolicy }),
+        ...(context.intent === undefined
+            ? {}
+            : { intent: context.intent }),
+        ...(context.submissionKey === undefined
+            ? {}
+            : { submissionKey: requireText(context.submissionKey, "Message submission key") }),
         ...(context.runId === undefined
             ? {}
             : { runId: requireSafeIdentity(context.runId, "Message AgentRun id") }),
@@ -57,6 +77,24 @@ export function updateDraftTaskMessage(message, update) {
     validateTaskMessage(updated);
     return updated;
 }
+/**
+ * Attach the §2.3 receipt a keyed submission earned, in the same transaction that
+ * saved and routed the Message. The receipt is a write-once fact: it is only set
+ * on a keyed Message that has none yet, so a replay (which never re-routes) can
+ * never overwrite the disposition the original submission recorded.
+ */
+export function withSubmissionReceipt(message, receipt) {
+    validateTaskMessage(message);
+    if (message.submissionKey === undefined) {
+        throw new Error(`A submission receipt requires a submission key: ${message.id}.`);
+    }
+    if (message.submissionReceipt !== undefined) {
+        throw new Error(`Submission receipt is already recorded: ${message.id}.`);
+    }
+    const updated = { ...message, submissionReceipt: receipt };
+    validateTaskMessage(updated);
+    return updated;
+}
 export function validateTaskMessage(message) {
     if (message.schemaVersion !== 3)
         throw new Error("Task Message must use schemaVersion 3.");
@@ -74,6 +112,24 @@ export function validateTaskMessage(message) {
         && message.kind !== "operator") {
         throw new Error("Message wakePolicy is only valid for user/operator messages.");
     }
+    if (message.intent !== undefined
+        && !TASK_SUBMISSION_INTENTS.includes(message.intent)) {
+        throw new Error(`Message intent is invalid: ${String(message.intent)}.`);
+    }
+    if (message.intent !== undefined
+        && message.kind !== "user"
+        && message.kind !== "operator") {
+        throw new Error("Message intent is only valid for user/operator messages.");
+    }
+    if (message.submissionKey !== undefined) {
+        requireText(message.submissionKey, "Message submission key");
+        if (message.kind !== "user" && message.kind !== "operator") {
+            throw new Error("Message submission key is only valid for user/operator messages.");
+        }
+    }
+    if (message.submissionReceipt !== undefined && message.submissionKey === undefined) {
+        throw new Error("Message submission receipt requires a submission key.");
+    }
     if (message.runId !== undefined)
         requireSafeIdentity(message.runId, "Message AgentRun id");
     if (message.recipient !== undefined) {

package/dist/plugins/pluginService.js

@@ -350,9 +350,17 @@ export function createPluginService(store, host, registry) {
             if (previous) {
                 const retired = previous;
                 void host.detach(retired.ref).catch((error) => {
-                    resources.saveArtifact(taskId, { kind: "content", displayName: "Plugin instance cleanup failure",
-                        provenance: `PluginService.dispose ${retired.ref.id}/${retired.ref.generation}`,
-                        content: error instanceof Error ? error.message : String(error) });
+                    // A post-publication detach failure is plugin operational telemetry,
+                    // recorded on the plugin's own failure channel — not a Task product
+                    // artifact (product artifacts are files in the Task's Git repository).
+                    try {
+                        store.recordPluginIntentFailure(taskId, retired.ref.id, intent.revision, {
+                            message: `Plugin instance cleanup failed for ${retired.ref.id}/${retired.ref.generation}: `
+                                + (error instanceof Error ? error.message : String(error)),
+                            occurredAt: new Date().toISOString()
+                        });
+                    }
+                    catch { /* best-effort telemetry; never mask the successful activation */ }
                 });
             }
             return { provider: ref, validationId, digest: pkg.digest, capabilities: entries.map((entry) => entry.name),

package/dist/resources/projectResource.js

@@ -25,54 +25,6 @@ export function validateExecutionEnvironmentSnapshot(value) {
 export function contentDigest(content) {
     return createHash("sha256").update(content, "utf8").digest("hex");
 }
-export function validateArtifact(artifact) {
-    if (artifact.schemaVersion !== 1)
-        throw new Error("Artifact schemaVersion must be 1.");
-    requireIdentity(artifact.id, "Artifact id");
-    requireIdentity(artifact.taskId, "Artifact Task");
-    requireText(artifact.displayName, "Artifact name");
-    requireText(artifact.mediaType, "Artifact media type");
-    requireText(artifact.provenance, "Artifact provenance");
-    requireTimestamp(artifact.createdAt, "Artifact timestamp");
-    if (artifact.kind === "content" || artifact.kind === "receipt") {
-        if (typeof artifact.content !== "string" || Buffer.byteLength(artifact.content) > 8 * 1024 * 1024) {
-            throw new Error("Artifact content must be UTF-8 text of at most 8 MiB.");
-        }
-        if (artifact.digest !== contentDigest(artifact.content))
-            throw new Error("Artifact content digest mismatch.");
-        if (artifact.kind === "receipt") {
-            requireIdentity(artifact.jobId, "Artifact Job");
-            requireText(artifact.receiptRef, "Artifact receipt");
-        }
-    }
-    else if (artifact.kind === "external-version") {
-        requireIdentity(artifact.resourceId, "Artifact resource");
-        requireText(artifact.version, "Artifact external version");
-        requireText(artifact.verification, "Artifact version verification");
-    }
-    else if (artifact.kind === "reference") {
-        requireText(artifact.locator, "Reference locator");
-        requireTimestamp(artifact.observedAt, "Reference observation");
-    }
-    else
-        throw new Error("Unknown Artifact kind.");
-    return artifact;
-}
-export function stableArtifactRef(artifact) {
-    validateArtifact(artifact);
-    if (artifact.kind === "reference")
-        throw new Error("Reference material is not a fixed result.");
-    return { taskId: artifact.taskId, artifactId: artifact.id, kind: artifact.kind,
-        ...("digest" in artifact ? { digest: artifact.digest } : {}) };
-}
-/** Listings expose locators and provenance without replaying every body. */
-export function artifactSummary(artifact) {
-    if ("content" in artifact) {
-        const { content, ...summary } = artifact;
-        return { ...summary, contentBytes: Buffer.byteLength(content, "utf8") };
-    }
-    return artifact;
-}
 export function validateLocalResource(resource) {
     if (resource.schemaVersion !== 1 || resource.kind !== "local-directory" || resource.ownership !== "user") {
         throw new Error("Invalid local Resource record.");

package/dist/resources/projectResourceService.js

@@ -1,46 +1,15 @@
 import { randomUUID } from "node:crypto";
-import { lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmdirSync, statSync } from "node:fs";
+import { lstatSync, mkdirSync, mkdtempSync, realpathSync, rmdirSync, statSync } from "node:fs";
 import { join, relative, resolve, isAbsolute } from "node:path";
 import { checkGrant, recordGrantUse } from "../grant/capabilityGrant.js";
-import { requireIdentity, requireText, requireTimestamp } from "../domain/validation.js";
+import { requireText } from "../domain/validation.js";
 import { validateProject } from "../repository/project.js";
 import { updateRole } from "../role/role.js";
 import { saveTaskRoleUpdate } from "../role/taskRoleUpdate.js";
 import { assertRoleRuntimeMutationAllowed } from "../commands/roleRuntimeGuard.js";
 import { assertProviderConversationReplaceable, currentProviderConversation } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
-import { contentDigest, validateArtifact, stableArtifactRef, validateExecutionEnvironmentSnapshot } from "./projectResource.js";
-export function validateArtifactInput(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("Artifact input must be an object.");
-    const input = value;
-    requireText(input.displayName, "Artifact name");
-    requireText(input.provenance, "Artifact provenance");
-    if (input.mediaType !== undefined)
-        requireText(input.mediaType, "Artifact media type");
-    switch (input.kind) {
-        case "content":
-            if (typeof input.content !== "string" || Buffer.byteLength(input.content) > 8 * 1024 * 1024) {
-                throw new Error("Artifact content must be UTF-8 text of at most 8 MiB.");
-            }
-            break;
-        case "receipt":
-            requireIdentity(input.jobId, "Artifact Job");
-            requireText(input.receiptRef, "Artifact receipt");
-            break;
-        case "external-version":
-            requireIdentity(input.resourceId, "Artifact resource");
-            requireText(input.version, "Artifact external version");
-            requireText(input.verification, "Artifact version verification");
-            break;
-        case "reference":
-            requireText(input.locator, "Reference locator");
-            requireTimestamp(input.observedAt, "Reference observation");
-            break;
-        default: throw new Error("Unknown Artifact kind.");
-    }
-    return input;
-}
+import { contentDigest, validateExecutionEnvironmentSnapshot } from "./projectResource.js";
 /** Trusted typed owner; the public caller is authenticated by the existing
  * capability boundary. No new Store, worker, scheduling or Git authority. */
 export function createProjectResources(store, now = () => new Date()) {
@@ -157,47 +126,6 @@ export function createProjectResources(store, now = () => new Date()) {
                 return updated;
             });
         },
-        saveArtifact(taskId, input) {
-            task(taskId);
-            validateArtifactInput(input);
-            const base = { schemaVersion: 1, taskId, id: `artifact-${randomUUID()}`,
-                displayName: input.displayName, mediaType: input.mediaType ?? "text/plain",
-                provenance: input.provenance, createdAt: now().toISOString() };
-            let artifact;
-            if (input.kind === "content") {
-                artifact = { ...base, kind: input.kind, content: input.content, digest: contentDigest(input.content) };
-            }
-            else if (input.kind === "receipt") {
-                const job = store.getDurableJob(taskId, input.jobId);
-                if (!job?.operation.receiptRefs.includes(input.receiptRef))
-                    throw new Error("Receipt is not recorded by this Task's Job.");
-                const path = realpathSync(input.receiptRef);
-                if (!within(realpathSync(job.artifactsLocator), path))
-                    throw new Error("Receipt is outside the Job artifact directory.");
-                const content = readText(path);
-                artifact = { ...base, kind: input.kind, jobId: job.id, receiptRef: input.receiptRef,
-                    content, digest: contentDigest(content) };
-            }
-            else if (input.kind === "external-version") {
-                // Recording supplied version evidence is not an external resource read.
-                // Actual resource operations must separately pass their owner's grant.
-                artifact = { ...base, kind: input.kind, resourceId: input.resourceId,
-                    version: input.version, verification: input.verification };
-            }
-            else {
-                artifact = { ...base, kind: input.kind, locator: input.locator, observedAt: input.observedAt };
-            }
-            store.saveArtifact(validateArtifact(artifact));
-            return artifact;
-        },
-        resultRefs(taskId, artifactIds) {
-            return artifactIds.map((id) => {
-                const artifact = store.getArtifact(taskId, id);
-                if (!artifact)
-                    throw new Error(`Artifact not found: ${taskId}/${id}.`);
-                return stableArtifactRef(artifact);
-            });
-        },
         gitResult(taskId, changeSetId) {
             const changeSet = store.getChangeSet(taskId, changeSetId);
             if (!changeSet)
@@ -413,9 +341,3 @@ function currentOrAbsentPath(path) {
         throw error;
     }
 }
-function readText(path) {
-    const stat = statSync(path);
-    if (!stat.isFile() || stat.size > 8 * 1024 * 1024)
-        throw new Error("Receipt must be a file of at most 8 MiB.");
-    return readFileSync(path, "utf8");
-}

package/dist/setup/setupCommand.js

@@ -53,15 +53,10 @@ export async function runSetupCommand(args, env, executor, io = {}) {
         return `${[
             "Yui setup complete.",
             `Yui home: ${home}.`,
-            `Operator Agent: ${agent.id}.`,
-            `Leader Agent: ${roleStatus.leaderAgentId}.`,
+            `Operator: ${agent.id} (${roleStatus.operator}).`,
+            `Leader: ${roleStatus.leaderAgentId} (${roleStatus.leader}).`,
             `Default workspace: ${workspace}.`,
-            `Operator configuration: ${roleStatus.operator}.`,
-            `Leader configuration: ${roleStatus.leader}.`,
-            `Tmux: ${tmuxBin}.`,
-            "Setup did not configure Review, Worker, Profiles, or shell completion.",
-            "Provider login and native key/initialization confirmations remain with the Provider; setup did not call a model.",
-            "Run `yui operator enter` to continue, or `yui config show` to inspect configuration."
+            "Run `yui config show` to inspect configuration, or `yui operator enter` to start an Operator session for configuration changes or development tasks."
         ].join("\n")}\n`;
     }
     finally {