@zq-silk/yui 2.3.0 → 2.4.0

package/dist/context/skillCatalog.js

@@ -0,0 +1,108 @@
+import { createHash } from "node:crypto";
+import { lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { verifySkillPackage } from "./skillPackage.js";
+import { BUILTIN_YUI_SKILLS } from "./roleSessionContext.js";
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/u;
+const MAX_TEXT = 256 * 1024;
+const digest = (data) => createHash("sha256").update(data).digest("hex");
+/** Read-only source discovery; browsing never snapshots, installs or executes a package. */
+export function skillSource(home, id) {
+    if (!SAFE_ID.test(id))
+        throw new Error("Invalid Skill id.");
+    const builtin = BUILTIN_YUI_SKILLS.has(id);
+    return { kind: builtin ? "builtin" : "configured",
+        path: builtin ? fileURLToPath(new URL(`../../skills/${id}`, import.meta.url)) : resolve(home, "skills", id) };
+}
+function physical(path) {
+    if (realpathSync(path) !== resolve(path))
+        throw new Error("Skill paths must not contain symlinks.");
+}
+function textFile(path) {
+    physical(path);
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.size > MAX_TEXT)
+        throw new Error("Only regular UTF-8 text files up to 256 KiB can be read.");
+    const bytes = readFileSync(path);
+    if (bytes.length > MAX_TEXT)
+        throw new Error("Skill content exceeds 256 KiB.");
+    const content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/u.test(content))
+        throw new Error("Binary Skill resources cannot be displayed.");
+    return { content, byteSize: bytes.length, fileDigest: digest(bytes) };
+}
+export function listSkillSources(home, query = "", cursor = "0") {
+    if (query.length > 256 || !/^\d{1,8}$/u.test(cursor))
+        throw new Error("Invalid Skill search or cursor.");
+    let configured = [];
+    try {
+        const directory = resolve(home, "skills");
+        physical(directory);
+        configured = readdirSync(directory).filter(id => SAFE_ID.test(id));
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    // Bounded discovery has an explicit limit, never silently presents a partial catalog.
+    if (configured.length > 2048)
+        throw new Error("Skill directory exceeds the 2048-entry browsing limit.");
+    const needle = query.trim().toLowerCase();
+    const items = [...new Set([...BUILTIN_YUI_SKILLS, ...configured])].sort().map(id => {
+        const source = skillSource(home, id);
+        try {
+            const file = textFile(join(source.path, "SKILL.md"));
+            const description = /^description:\s*(.+)$/mu.exec(file.content)?.[1]
+                ?? file.content.split("\n").find(line => line.trim() && !line.startsWith("#")) ?? "";
+            return { id, source, description: description.slice(0, 600), error: null };
+        }
+        catch (error) {
+            return { id, source, description: "", error: error instanceof Error ? error.message : String(error) };
+        }
+    }).filter(item => !needle || `${item.id} ${item.description}`.toLowerCase().includes(needle));
+    const offset = Number(cursor);
+    return { items: items.slice(offset, offset + 30), total: items.length,
+        nextCursor: offset + 30 < items.length ? String(offset + 30) : null };
+}
+export function readSkillSource(home, id, resource = "SKILL.md") {
+    const source = skillSource(home, id);
+    const files = [];
+    let entries = 0;
+    function walk(path, depth) {
+        if (depth > 32)
+            throw new Error("Skill resource depth exceeds 32.");
+        physical(path);
+        for (const name of readdirSync(path).sort()) {
+            if (++entries > 4096)
+                throw new Error("Skill exceeds the 4096-entry browsing limit.");
+            const child = join(path, name);
+            const stat = lstatSync(child);
+            if (stat.isSymbolicLink() || !stat.isDirectory() && !stat.isFile())
+                throw new Error("Skill contains a symlink or special file.");
+            if (stat.isDirectory())
+                walk(child, depth + 1);
+            else
+                files.push(relative(source.path, child).split(sep).join("/"));
+            if (files.length > 2048)
+                throw new Error("Skill contains more than 2048 resources.");
+        }
+    }
+    walk(source.path, 0);
+    if (!files.includes("SKILL.md"))
+        throw new Error("Skill entrypoint SKILL.md is missing.");
+    if (!files.includes(resource))
+        throw new Error("Resource is not in this Skill package.");
+    return { id, source, version: "current-source", resource, files, ...textFile(join(source.path, resource)) };
+}
+/** The reference must come from a stored Session/Run, never from client paths. */
+export function readFrozenSkill(ref, resource) {
+    const manifest = verifySkillPackage(ref);
+    const root = join(dirname(ref.manifestPath), "files");
+    const entrypoint = relative(root, join(ref.path, "SKILL.md")).split(sep).join("/");
+    const selected = resource ?? entrypoint;
+    if (!manifest.files.some(file => file.path === selected))
+        throw new Error("Resource is not in this frozen Skill package.");
+    return { id: ref.id, source: ref.source, version: ref.digest, resource: selected,
+        files: manifest.files.map(file => file.path), ...textFile(join(root, selected)) };
+}

package/dist/context/skillPackage.js

@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+const MAX_FILES = 2048;
+const MAX_BYTES = 32 * 1024 * 1024;
+const MAX_FILE_BYTES = 8 * 1024 * 1024;
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+/** A package is data: no script, hook or executable is invoked while loading it.
+ * Builtin Skills share one tree so their sibling-relative references stay valid. */
+export function snapshotSkillPackage(input) {
+    const root = resolve(input.root);
+    assertPhysical(root);
+    const files = [];
+    const contents = new Map();
+    let byteSize = 0;
+    function walk(directory, depth) {
+        if (depth > 32)
+            throw new Error("Skill package directory depth exceeds 32.");
+        for (const name of readdirSync(directory).sort()) {
+            if (name.includes("\\") || /[\x00-\x1f\x7f]/u.test(name)) {
+                throw new Error(`Invalid Skill resource name: ${JSON.stringify(name)}.`);
+            }
+            const path = join(directory, name);
+            const stat = lstatSync(path);
+            if (stat.isDirectory()) {
+                walk(path, depth + 1);
+                continue;
+            }
+            if (!stat.isFile())
+                throw new Error(`Skill package requires regular files, not symlinks or special files: ${path}.`);
+            if (files.length >= MAX_FILES || stat.size > MAX_FILE_BYTES || byteSize + stat.size > MAX_BYTES) {
+                throw new Error(`Skill package exceeds limits (${MAX_FILES} files, 8 MiB/file, 32 MiB total).`);
+            }
+            const bytes = readFileSync(path);
+            if (bytes.length !== stat.size)
+                throw new Error(`Skill resource changed while reading: ${path}.`);
+            byteSize += bytes.length;
+            const entry = { path: relative(root, path).split(sep).join("/"), digest: hash(bytes),
+                size: bytes.length, executable: (stat.mode & 0o111) !== 0 };
+            files.push(entry);
+            contents.set(entry.path, bytes);
+        }
+    }
+    walk(root, 0);
+    files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    const subdirectory = input.subdirectory ?? "";
+    const entrypoint = subdirectory ? `${subdirectory}/SKILL.md` : "SKILL.md";
+    if (!contents.has(entrypoint))
+        throw new Error(`Configured Skill not found: ${input.id}.`);
+    // Names, raw bytes and executable intent all participate; mtimes and source
+    // locations do not. Identical bundles deduplicate across Roles and Sessions.
+    const digest = hash(JSON.stringify(files));
+    const parent = resolve(input.home, "runtime", "skill-packages");
+    mkdirSync(parent, { recursive: true, mode: 0o700 });
+    assertPhysical(parent);
+    const destination = join(parent, digest);
+    const manifest = { schemaVersion: 1, files, digest };
+    if (!existsSync(destination)) {
+        const staging = mkdtempSync(join(parent, ".staging-"));
+        try {
+            for (const file of files) {
+                const path = join(staging, "files", file.path);
+                mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+                writeFileSync(path, contents.get(file.path), { flag: "wx", mode: file.executable ? 0o500 : 0o400 });
+            }
+            writeFileSync(join(staging, "manifest.json"), JSON.stringify(manifest), { flag: "wx", mode: 0o400 });
+            try {
+                renameSync(staging, destination);
+            }
+            catch (error) {
+                if (!existsSync(destination))
+                    throw error;
+                // Another producer can have won the same content-addressed destination.
+            }
+        }
+        finally {
+            rmSync(staging, { recursive: true, force: true });
+        }
+    }
+    const ref = {
+        id: input.id, path: join(destination, "files", subdirectory), digest,
+        source: { kind: input.kind, path: join(root, subdirectory) },
+        manifestPath: join(destination, "manifest.json"), fileCount: files.length, byteSize
+    };
+    verifySkillPackage(ref);
+    return ref;
+}
+export function validateSkillPackageRef(ref) {
+    if (ref === null || typeof ref !== "object"
+        || !/^[A-Za-z0-9][A-Za-z0-9_-]*$/u.test(ref.id)
+        || !/^[a-f0-9]{64}$/u.test(ref.digest)
+        || typeof ref.path !== "string" || !isAbsolute(ref.path)
+        || typeof ref.manifestPath !== "string" || !isAbsolute(ref.manifestPath)
+        || basename(dirname(ref.manifestPath)) !== ref.digest || basename(ref.manifestPath) !== "manifest.json"
+        || !ref.source || !["builtin", "configured"].includes(ref.source.kind)
+        || typeof ref.source.path !== "string" || !isAbsolute(ref.source.path)
+        || !Number.isSafeInteger(ref.fileCount) || ref.fileCount < 1 || ref.fileCount > MAX_FILES
+        || !Number.isSafeInteger(ref.byteSize) || ref.byteSize < 0 || ref.byteSize > MAX_BYTES) {
+        throw new Error("Skill package reference is invalid.");
+    }
+}
+/** Fail closed on lost/corrupt snapshots. Never refill them from mutable sources. */
+export function verifySkillPackage(ref) {
+    validateSkillPackageRef(ref);
+    const root = join(dirname(ref.manifestPath), "files");
+    assertPhysical(dirname(ref.manifestPath));
+    assertPhysical(ref.manifestPath);
+    if (lstatSync(ref.manifestPath).size > 1024 * 1024)
+        throw new Error("Skill package manifest exceeds limits.");
+    const manifest = JSON.parse(readFileSync(ref.manifestPath, "utf8"));
+    if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.files)
+        || manifest.digest !== ref.digest || hash(JSON.stringify(manifest.files)) !== ref.digest
+        || manifest.files.length !== ref.fileCount)
+        throw new Error("Skill package manifest digest mismatch.");
+    const entrypoint = relative(root, join(ref.path, "SKILL.md")).split(sep).join("/");
+    let byteSize = 0;
+    const paths = new Set();
+    for (const file of manifest.files) {
+        if (typeof file.path !== "string" || !file.path || file.path.split("/").some((part) => part === ".." || part === "." || part === "")
+            || file.path.includes("\\") || isAbsolute(file.path) || paths.has(file.path)) {
+            throw new Error("Skill package resource path is invalid.");
+        }
+        paths.add(file.path);
+        const path = join(root, file.path);
+        assertPhysical(path);
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.size !== file.size || stat.size > MAX_FILE_BYTES
+            || ((stat.mode & 0o111) !== 0) !== file.executable
+            || hash(readFileSync(path)) !== file.digest)
+            throw new Error(`Skill package resource changed: ${file.path}.`);
+        byteSize += file.size;
+    }
+    if (!paths.has(entrypoint) || byteSize !== ref.byteSize)
+        throw new Error("Skill package entrypoint or size mismatch.");
+    let observed = 0;
+    function checkInventory(directory, depth) {
+        if (depth > 32)
+            throw new Error("Skill package directory depth exceeds 32.");
+        for (const name of readdirSync(directory)) {
+            const path = join(directory, name);
+            const stat = lstatSync(path);
+            if (stat.isDirectory()) {
+                checkInventory(path, depth + 1);
+                continue;
+            }
+            if (!stat.isFile() || !paths.has(relative(root, path).split(sep).join("/"))) {
+                throw new Error("Skill package contains an unrecorded resource.");
+            }
+            observed++;
+        }
+    }
+    checkInventory(root, 0);
+    if (observed !== paths.size)
+        throw new Error("Skill package inventory changed.");
+    return manifest;
+}
+function assertPhysical(path) {
+    if (realpathSync(path) !== resolve(path)) {
+        throw new Error(`Skill package paths must not contain symlinks: ${path}.`);
+    }
+}

package/dist/context/taskContext.js

@@ -580,7 +580,8 @@ function freeze(value) {
 }
 function summarize(value) {
     const record = value;
-    return ["title", "objective", "question", "summary", "body", "status", "type"]
-        .flatMap((key) => typeof record[key] === "string" ? [`${key}: ${record[key]}`] : [])
+    return ["title", "scope", "expiresWhen", "version", "objective", "question", "summary", "body", "status", "type"]
+        .flatMap((key) => typeof record[key] === "string" || (key === "version" && typeof record[key] === "number")
+        ? [`${key}: ${record[key]}`] : [])
         .join("; ").slice(0, 400);
 }

package/dist/context/taskSearch.js

@@ -0,0 +1,127 @@
+import { usageError } from "../errors/cliError.js";
+import { TASK_SEARCH_KINDS } from "../storage/taskSearch.js";
+import { contextContentDigest } from "./contextSnapshot.js";
+import { taskCatalogScope } from "./taskCatalog.js";
+import { readTaskContextResource } from "./taskContext.js";
+const PAGE_BYTES = 32 * 1024;
+/** Human-readable field pages, using the same source authorization and version
+ * checks as Context. Offsets are Unicode code points, like search snippets. */
+export function readTaskSearchSource(store, taskId, input, environment = {}) {
+    if (!input.digest || !Number.isSafeInteger(input.offset) || input.offset < 0) {
+        throw usageError("A pinned digest and non-negative source offset are required.");
+    }
+    const fields = {
+        "task-brief": /^\$\.(objective|technicalApproach|currentFocus|leaderSummary|boundaries\[\d+\])$/,
+        "task-message": /^\$\.body$/,
+        "task-decision": /^\$\.(title|rationale|supersededReason)$/,
+        "run": /^\$\.result\.output$/,
+        "task": /^\$\.completionSummary$/
+    };
+    if (!fields[input.store]?.test(input.field))
+        throw usageError("Unsupported search source field.");
+    const original = readTaskContextResource(store, taskId, input, environment);
+    let value = original.value;
+    for (const part of input.field.slice(2).replace(/\[(\d+)\]/g, ".$1").split(".")) {
+        value = value && typeof value === "object" ? value[part] : undefined;
+    }
+    if (typeof value !== "string")
+        throw usageError("Search source text is unavailable.");
+    const points = Array.from(value);
+    if (input.offset > points.length)
+        throw usageError("Source offset is outside the text.");
+    const end = Math.min(input.offset + 4000, points.length);
+    return { taskId, ref: original.ref, field: input.field, authority: "reference-only",
+        content: points.slice(input.offset, end).join(""), offset: input.offset,
+        nextOffset: end < points.length ? end : null, totalCharacters: points.length,
+        offsetUnit: "unicode-code-points" };
+}
+export function parseTaskSearchOptions(args) {
+    const query = args[0]?.trim();
+    if (!query || query.length > 256 || query.includes("\0"))
+        throw usageError("Task search requires a query of 1..256 characters.");
+    const values = new Map();
+    for (let i = 1; i < args.length; i += 2) {
+        const key = args[i];
+        const value = args[i + 1];
+        if (!["--task", "--kind", "--limit", "--cursor"].includes(key) || values.has(key)
+            || value === undefined || value.startsWith("--"))
+            throw usageError("Task search expects query [--task <id>] [--kind <kind>] [--limit <1..100>] [--cursor <cursor>].");
+        values.set(key, value);
+    }
+    const limit = values.has("--limit") ? Number(values.get("--limit")) : 20;
+    const kind = values.get("--kind");
+    const taskId = values.get("--task");
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+        throw usageError("Task search limit must be between 1 and 100.");
+    if (kind !== undefined && !TASK_SEARCH_KINDS.includes(kind))
+        throw usageError("Unknown Task search kind.");
+    if (taskId !== undefined && !/^task-[1-9]\d*$/.test(taskId))
+        throw usageError("Invalid Task search target.");
+    return { query, limit, ...(kind ? { kind } : {}), ...(taskId ? { taskId } : {}),
+        ...(values.has("--cursor") ? { cursor: values.get("--cursor") } : {}) };
+}
+export function searchTaskBodies(store, options, environment = {}) {
+    // Validate typed callers as well as CLI/HTTP callers through one parser.
+    const valid = parseTaskSearchOptions([options.query, "--limit", String(options.limit),
+        ...(options.taskId === undefined ? [] : ["--task", options.taskId]),
+        ...(options.kind === undefined ? [] : ["--kind", options.kind]),
+        ...(options.cursor === undefined ? [] : ["--cursor", options.cursor])]);
+    return store.readTransaction(reader => {
+        const callerTask = taskCatalogScope(reader, environment);
+        if (callerTask !== undefined && valid.taskId !== undefined && callerTask !== valid.taskId) {
+            throw usageError("Search target is outside the caller's Task.");
+        }
+        const taskId = callerTask ?? valid.taskId;
+        const scope = contextContentDigest({ taskId: taskId ?? null, query: valid.query, kind: valid.kind ?? null });
+        const after = valid.cursor === undefined ? undefined : decodeCursor(valid.cursor, scope);
+        const rows = reader.queryTaskSearch({ ...valid, taskId, after, limit: valid.limit + 1 });
+        const items = [];
+        let nextCursor = null;
+        const response = () => ({
+            query: valid.query, scope: { taskId: taskId ?? null, archived: "included" },
+            items, nextCursor, consistency: "current-per-page; repeat search after source changes",
+            matching: "literal substring; ASCII case-insensitive; Unicode otherwise exact",
+            limits: { maxItems: valid.limit, pageBytes: PAGE_BYTES, snippetCodePoints: 320 },
+            reuse: "References are evidence, not execution authority. An authorized reader may supply selected source text and its reference to a new Task; that Task plans and obtains its own authority."
+        });
+        for (const row of rows.slice(0, valid.limit)) {
+            // Reuse the exact Context permission and digest contract for each hit.
+            const original = readTaskContextResource(reader, row.taskId, { store: row.store, refId: row.refId }, environment);
+            const item = { taskId: row.taskId, kind: row.kind, field: row.field, snippet: row.snippet,
+                offset: row.offset, ref: original.ref, authority: "reference-only" };
+            const previous = nextCursor;
+            nextCursor = encodeCursor(scope, row);
+            items.push(item);
+            if (Buffer.byteLength(JSON.stringify({ ok: true, data: response() })) > PAGE_BYTES) {
+                items.pop();
+                nextCursor = previous;
+                break;
+            }
+        }
+        if (rows.length === items.length)
+            nextCursor = null;
+        if (rows.length && !items.length)
+            throw usageError("Task search identity exceeds its page budget.");
+        return response();
+    });
+}
+function encodeCursor(scope, row) {
+    return Buffer.from(JSON.stringify({ version: 1, scope, after: {
+            taskId: row.taskId, kind: row.kind, refId: row.refId, field: row.field
+        } })).toString("base64url");
+}
+function decodeCursor(raw, scope) {
+    try {
+        if (raw.length > 4096 || !/^[A-Za-z0-9_-]+$/.test(raw))
+            throw new Error();
+        const value = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"));
+        if (value.version !== 1 || value.scope !== scope || !value.after
+            || !["taskId", "kind", "refId", "field"].every(key => typeof value.after[key] === "string"
+                && value.after[key].length > 0 && value.after[key].length <= 256))
+            throw new Error();
+        return value.after;
+    }
+    catch {
+        throw usageError("Invalid Task search cursor or cursor belongs to another scope/query.");
+    }
+}

package/dist/controlPlaneCli.js

@@ -36,7 +36,7 @@ import { runConfigOverview } from "./commands/configOverview.js";
 import { parseControllerCleanupOptions, parseControllerRuntimeSnapshot, parseControllerStatusOptions, renderControllerResourceStatus, renderRuntimeIdentitySection, runInteractiveControllerCleanup, summarizeDurablePhysicalMismatch } from "./commands/controllerCommands.js";
 import { runDurableJobCommand } from "./commands/durableJobCommands.js";
 import { parseExecutionAuditOptions, runExecutionAuditCommand } from "./commands/executionAuditCommands.js";
-import { runGlobalRoleCommand } from "./commands/globalRoleCommands.js";
+import { runGlobalRoleCommand, previewGlobalRoleAgentConfigurationMutation } from "./commands/globalRoleCommands.js";
 import { runJobCommand } from "./commands/jobCommands.js";
 import { applyOperatorSessionControl, runOperatorCommand } from "./commands/operatorCommands.js";
 import { previewProfileAgentConfigurationMutation, runProfileCommand } from "./commands/profileCommands.js";
@@ -110,7 +110,7 @@ import { inspectStorageSchema } from "./storage/storageSchema.js";
 import { resolveYuiHome } from "./storage/taskStore.js";
 import { renderArchiveDiagnostics, taskArchiveDiagnostics } from "./task/archiveDiagnostics.js";
 import { inspectTaskArchive, renderTaskArchivePreflight } from "./task/archivePreflight.js";
-import { assertTaskRemoteDeliveryIntegrated, createTaskRemoteDeliveryProof } from "./task/remoteDeliveryService.js";
+import { archiveOrdinaryTask } from "./task/ordinaryArchive.js";
 import { resolveTaskRecordReference } from "./task/taskRecordReference.js";
 import { openSchedulerTelemetry } from "./telemetry/telemetryWiring.js";
 import { NodeCommandExecutor } from "./tmux/commandExecutor.js";
@@ -704,7 +704,8 @@ export async function main() {
             const domain = resolved[1];
             const roleOptions = {
                 yuiHome: home,
-                env: process.env
+                env: process.env,
+                ...(validateAgentConfiguration === undefined ? {} : { validateAgentConfiguration })
             };
             if (domain === "show") {
                 const result = runConfigOverview(resolved.slice(2), store, process.env, roleOptions);
@@ -1039,7 +1040,7 @@ export async function main() {
                 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>]";
+                    + "save <task> <relative-path> <content> [--encoding utf8|base64] [--message <text>] [--expected-head <commit>]";
                 if (taskId === undefined || action === undefined || !["list", "read", "save"].includes(action)) {
                     throw usageError(usage);
                 }
@@ -1073,6 +1074,7 @@ export async function main() {
                     const rest = resolved.slice(6);
                     let message;
                     let expectedHead;
+                    let encoding;
                     for (let index = 0; index < rest.length; index += 1) {
                         const value = rest[index + 1];
                         if (rest[index] === "--message" && value !== undefined) {
@@ -1085,10 +1087,15 @@ export async function main() {
                             index += 1;
                             continue;
                         }
+                        if (rest[index] === "--encoding" && (value === "utf8" || value === "base64")) {
+                            encoding = value;
+                            index += 1;
+                            continue;
+                        }
                         throw usageError(usage);
                     }
                     data = await saveArtifactCapability(home, taskId, {
-                        relativePath, content,
+                        relativePath, content, ...(encoding === undefined ? {} : { encoding }),
                         ...(message === undefined ? {} : { message }),
                         ...(expectedHead === undefined ? {} : { expectedHead })
                     });
@@ -1320,8 +1327,6 @@ export async function main() {
                 });
                 return;
             }
-            let archiveRemoteDeliveryProof;
-            let archiveTaskReviewCandidate;
             if (resolved[1] === "archive") {
                 const request = parseTaskArchiveArguments(resolved.slice(2));
                 if (request.sourceMessage !== undefined) {
@@ -1359,15 +1364,17 @@ export async function main() {
                     emit(`Archived task ${taskId}\n${renderArchiveDiagnostics(archive)}`, false, { task: current, ...archive });
                     return;
                 }
+                if (disposition === "integrated") {
+                    const result = await archiveOrdinaryTask(workspaceCoordinator, taskId, {
+                        runtime, environment: process.env, yuiHome: home
+                    });
+                    emit(`Archived task ${taskId}\n${renderArchiveDiagnostics(result)}`, false, result);
+                    return;
+                }
                 {
-                    if (disposition === "integrated") {
-                        archiveTaskReviewCandidate = task.status === "cancelled" ? await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env) : undefined;
-                        archiveRemoteDeliveryProof = createTaskRemoteDeliveryProof(store, task, archiveTaskReviewCandidate ?? null);
-                        assertTaskRemoteDeliveryIntegrated(archiveRemoteDeliveryProof.delivery);
-                    }
                     await workspaceCoordinator.prepareTaskForArchive(task.id);
                     runTaskCommand(resolved.slice(1), store, {
-                        runtime, environment: process.env, yuiHome: home, archiveRemoteDeliveryProof
+                        runtime, environment: process.env, yuiHome: home
                     });
                     await workspaceCoordinator.cleanupArchivedTask(task.id, disposition);
                     const current = store.getTask(task.id);
@@ -1527,9 +1534,7 @@ export async function main() {
                     laneDispatchProjectPaths = preparedLanes.projectPaths;
                 }
                 const candidateSnapshots = await candidateSnapshotForTaskCommand(resolved, store, workspacePreparer, process.env, taskFinalReviewContract);
-                const actualTaskReviewCandidate = archiveRemoteDeliveryProof === undefined
-                    ? await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env)
-                    : archiveTaskReviewCandidate;
+                const actualTaskReviewCandidate = await actualTaskReviewCandidateForTaskCommand(resolved, store, workspacePreparer, process.env);
                 const deltaRecheckPreflight = await deltaRecheckPreflightForTaskCommand(resolved.slice(1), store, actualTaskReviewCandidate);
                 // Read-only Host evidence for Session inspect and Role status/list. The command stays
                 // synchronous over persisted state; this is the live reading it prints
@@ -1569,9 +1574,6 @@ export async function main() {
                     ...(actualTaskReviewCandidate === undefined
                         ? {}
                         : { actualTaskReviewCandidate }),
-                    ...(archiveRemoteDeliveryProof === undefined
-                        ? {}
-                        : { archiveRemoteDeliveryProof }),
                     ...(deltaRecheckPreflight === undefined
                         ? {}
                         : { deltaRecheckPreflight }),
@@ -2721,7 +2723,10 @@ function selectionPorts(store, catalogs) {
 }
 async function preflightAgentConfigurationMutation(commandArgs, store, catalogs) {
     const mutation = profileAgentConfigurationMutation(commandArgs, store)
-        ?? taskRoleAgentConfigurationMutation(commandArgs, store);
+        ?? taskRoleAgentConfigurationMutation(commandArgs, store)
+        ?? (commandArgs[0] === "config" && commandArgs[1] === "role"
+            ? previewGlobalRoleAgentConfigurationMutation(commandArgs.slice(2), store, { yuiHome: store.rootDirectory() })
+            : undefined);
     if (mutation === undefined) {
         await warmConfigurationMutationCatalog(commandArgs, store, catalogs);
         return undefined;

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -35,7 +35,7 @@ import { classifyRuntimeProcessExit, validateRuntimeProcessExitObservation } fro
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
 import { acceptProviderTurn, beginProviderTurn, cancelQuiescentProviderInput, clearProviderGoal, createProviderRuntimeBinding, currentProviderConversation, managedProviderTurnId, settleProviderTurn, settleProviderTurnSubmission, supersedeProviderConversation, transferProviderAuthority, updateProviderConversationRecoverability, updateProviderGoal } from "../runtime/providerRuntimeIdentity.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
-import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeTokenEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation, isRuntimeUsageEvidence, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches, runtimeObservationTaskEventPayload } from "../runtime/runtimeObservation.js";
 import { recordLeaderFailure } from "../scheduler/leaderFailure.js";
 import { enqueueSupervisorEvent, recordLeaderAttentionRequired, routeRoleEvent } from "../scheduler/operatorEvent.js";
 import { RUN_DIAGNOSTIC_FINISHED_EVENT, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT, foldRunProgressFacts, isRoleRunStalled, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey } from "../scheduler/roleRunStall.js";
@@ -1192,6 +1192,16 @@ export class FileSchedulerStoreAdapter {
                 throw new AgentHostProviderTurnFenceError("Agent Host Provider Turn carries a stale durable writer fence. Release and reacquire Provider authority before retrying input.");
             }
             const currentRun = binding.run;
+            if (input.roleName === "leader" && input.attemptId.startsWith(`notification:${input.taskId}/`)) {
+                const wakeId = input.attemptId.split("/")[1];
+                const wake = store.listTaskWakes(input.taskId).find(w => w.id === wakeId);
+                const ids = new Set(wake?.refs?.filter(r => r.type === "message").map(r => r.id));
+                if (store.listMessages(input.taskId).some(m => ids.has(m.id)
+                    && m.inputControl?.expectedSessionId !== undefined
+                    && m.inputControl.expectedSessionId !== input.nativeSessionId)) {
+                    throw new AgentHostProviderTurnFenceError("Notification input belongs to the selected old Session; do not retarget.");
+                }
+            }
             if (session.effective.executionEnvironment !== undefined) {
                 assertExecutionEnvironmentCurrent(store, input.taskId, session.effective.executionEnvironment);
             }
@@ -1248,7 +1258,7 @@ export class FileSchedulerStoreAdapter {
             // before the Provider write; provider-visible userMessage items alone
             // are NOT proof of human authorship (managed prompts use those too).
             // This shares the exact writer/session admission and its transaction.
-            if (input.authorityOwner === "human" && input.roleName === "leader"
+            if ((input.authorityOwner === "human" || input.attemptId.startsWith(`human:${input.holderId}:`)) && input.roleName === "leader"
                 && input.runId === undefined && input.boundedText !== undefined) {
                 const prior = store.listEvents(input.taskId).find(event => event.type === "message.native-user-input" && event.payload.attemptId === input.attemptId);
                 if (prior !== undefined) {
@@ -1770,7 +1780,7 @@ export class FileSchedulerStoreAdapter {
                 directive: `Plan Task ${taskId} with the user. Persist requirements and decisions. Request activation explicitly; planning grants no delivery authority.`,
                 contextSnapshotRef: contextSnapshotRef(snapshot),
                 deltaRefIds: [] }), now, {
-                purpose: "planning", effective: resolveEffectiveLaunch({ role, purpose: "planning" })
+                purpose: "planning", effective: resolveEffectiveLaunch({ store, role, purpose: "planning" })
             });
             store.saveRun(run);
             store.saveActiveRun(run);
@@ -1849,6 +1859,18 @@ export class FileSchedulerStoreAdapter {
             const sessions = store.getTaskRoleSessionSet(taskId, "leader");
             const session = sessions?.sessions[sessions.activeAgentId];
             const obsoleteIds = new Set();
+            for (const message of store.listMessages(taskId)) {
+                if (!pendingMessageIds.has(message.id) || message.inputControl?.expectedSessionId === undefined)
+                    continue;
+                if (message.inputControl.expectedSessionId !== session?.nativeSessionId
+                    || message.continuation?.notDeliveredReason !== undefined) {
+                    obsoleteIds.add(message.id);
+                    if (message.continuation?.notDeliveredReason === undefined)
+                        store.updateMessage(taskId, {
+                            ...message, continuation: { notDeliveredReason: "selected-native-session-changed" }
+                        });
+                }
+            }
             for (const message of claimedMessages) {
                 const claim = message.interruptThen;
                 if (claim.notDeliveredReason !== undefined
@@ -3136,6 +3158,7 @@ function mapRole(store, role) {
     // Active AgentRun delivery separately and exclusively uses turn.effective.
     const effective = reopened || (liveSession !== null && liveSession.agentId !== role.activeAgentId)
         ? resolveEffectiveLaunch({
+            store,
             role,
             purpose,
             ...(workspace === undefined ? {} : { workspace }),
@@ -3144,6 +3167,7 @@ function mapRole(store, role) {
         : liveSession !== null && workspace?.owner.type === "task"
             ? effectiveLaunchWithTaskMainWorkspace(liveSession.effective, workspace)
             : liveSession?.effective ?? resolveEffectiveLaunch({
+                store,
                 role,
                 purpose,
                 ...(workspace === undefined ? {} : { workspace }),
@@ -3199,6 +3223,8 @@ function taskSessionEffective(store, taskId, roleName, agentId, existing) {
     return effective;
 }
 function globalSessionEffective(role, existing) {
+    // A native hook without a captured launch is not proof of loaded resources.
+    // Actual controlled launches supply their frozen effective snapshot explicitly.
     return existing?.effective ?? resolveEffectiveLaunch({ role, purpose: "execution" });
 }
 function mapSession(session) {
@@ -3292,10 +3318,10 @@ function compactedRuntimeObservationIds(events, incoming) {
     });
     const remove = ({ observation }) => {
         if (incoming.kind === "activity.observed") {
-            if (isRuntimeTokenEvidence(incoming))
+            if (isRuntimeUsageEvidence(incoming))
                 return false;
             return observation.kind === "activity.observed"
-                && !isRuntimeTokenEvidence(observation);
+                && !isRuntimeUsageEvidence(observation);
         }
         if (incoming.kind === "operation.started") {
             return (observation.kind === "operation.started"
@@ -3549,7 +3575,7 @@ function usageSnapshotIsSuperseded(events, incoming) {
         && observationIsStrictlyNewer(observation, incoming));
 }
 function hasPersistedRuntimeObservation(events, incoming) {
-    const usageIdentity = isRuntimeTokenEvidence(incoming)
+    const usageIdentity = isRuntimeUsageEvidence(incoming)
         ? incoming.eventId
         : undefined;
     return events.some((event) => (event.type === RUNTIME_OBSERVATION_TASK_EVENT