@zq-silk/yui 0.15.7 → 0.15.8

package/dist/plugins/pluginService.js

@@ -0,0 +1,380 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { checkGrant, recordGrantUse } from "../grant/capabilityGrant.js";
+import { createProjectResources } from "../resources/projectResourceService.js";
+import { CapabilityExecutionError } from "../kernel/capabilityRegistry.js";
+import { validatePluginId } from "./pluginIntent.js";
+import { packagePath, readPluginPackage } from "./pluginPackage.js";
+import { interpretPlugin } from "./pluginInterpreter.js";
+import { PluginProcess, pluginProcessEnvironment } from "./pluginProcess.js";
+const execute = promisify(execFile);
+/** SDK management owner. The Store owns desired selection and validation;
+ * the Host alone owns live implementations. Reading/restarting never executes
+ * author code or treats saved intent as a grant. */
+export function createPluginService(store, host, registry) {
+    const resources = createProjectResources(store);
+    const active = new Map();
+    // Resource references mirror actual SDK operations/Host ownership only.
+    // They prevent explicit environment release while those owners still use it.
+    const environmentUsers = new Map();
+    const retainEnvironment = (taskId, preparationId) => {
+        const token = {};
+        environmentUsers.set(token, { taskId, preparationId });
+        return () => { environmentUsers.delete(token); };
+    };
+    const keyFor = (taskId, pluginId) => `plugin:${taskId}:${pluginId}`;
+    const selection = (taskId, validationId) => {
+        const report = store.getPluginValidation(taskId, validationId);
+        if (!report)
+            throw new Error("Plugin selection references missing validation evidence.");
+        return { validationId, version: report.package.manifest.version, digest: report.package.digest };
+    };
+    const inspect = (taskId, pluginId) => {
+        validatePluginId(pluginId);
+        return store.transaction(() => {
+            const desired = store.getPluginIntent(taskId, pluginId);
+            const selected = active.get(keyFor(taskId, pluginId));
+            const actual = selected && host.isAvailable(selected.ref)
+                ? { ...selection(taskId, selected.validationId), provider: selected.ref } : null;
+            return {
+                pluginId, scope: { kind: "task", id: taskId },
+                desired: desired === null ? null : {
+                    ...desired, ...(desired.validationId === undefined ? {} : selection(taskId, desired.validationId))
+                },
+                actual,
+                instances: host.inspect(keyFor(taskId, pluginId)),
+                needsActivation: desired?.enabled === true && desired.validationId !== actual?.validationId
+            };
+        });
+    };
+    const choose = (taskId, pluginId, enabled, validationId) => store.transaction(() => {
+        const previous = store.getPluginIntent(taskId, pluginId);
+        const chosen = validationId ?? previous?.validationId;
+        const intent = {
+            schemaVersion: 1, taskId, pluginId, revision: (previous?.revision ?? 0) + 1,
+            enabled, ...(chosen === undefined ? {} : { validationId: chosen }), updatedAt: new Date().toISOString()
+        };
+        store.savePluginIntent(intent);
+        return intent;
+    });
+    const fail = (intent, error) => {
+        let message = error instanceof Error ? error.message : String(error);
+        try {
+            store.recordPluginIntentFailure(intent.taskId, intent.pluginId, intent.revision, { message, occurredAt: new Date().toISOString() });
+        }
+        catch (recordError) {
+            message += `; failure diagnostic could not be saved: ${recordError instanceof Error ? recordError.message : String(recordError)}`;
+        }
+        return new CapabilityExecutionError(message, inspect(intent.taskId, intent.pluginId));
+    };
+    const environment = (taskId, preparationId) => {
+        const task = store.getTask(taskId);
+        if (!task || !["draft", "active"].includes(task.status))
+            throw new Error("Plugin environment requires an open Task.");
+        const prepared = store.getEnvironmentPreparation(taskId, preparationId);
+        if (!prepared || prepared.disposition !== "adopted" || !prepared.directory || prepared.access !== "write") {
+            throw new Error("Plugin development/execution requires an adopted writable T05 environment.");
+        }
+        // Reuse the same current-adoption proof as native execution, including
+        // the resource grant reservation. A new grant alone is not re-adoption.
+        resources.resolveExecutionEnvironment(taskId, preparationId);
+        return prepared;
+    };
+    const packageDirectory = (taskId, preparationId, directory) => {
+        const env = environment(taskId, preparationId);
+        const root = env.directory.path;
+        const path = resolve(root, directory);
+        const child = relative(root, path);
+        packagePath(child);
+        if (realpathSync(path) !== path)
+            throw new Error("Plugin directory must not traverse symlinks.");
+        return { env, path };
+    };
+    const descriptors = (taskId, pkg, ref) => pkg.manifest.capabilities.map((capability) => ({
+        ...capability, provider: ref, scope: { kind: "task", id: taskId },
+        source: `plugin:${pkg.manifest.id}@${pkg.digest}`, required: pkg.manifest.required
+    }));
+    const refFor = (taskId, pkg) => ({ id: keyFor(taskId, pkg.manifest.id), generation: randomUUID() });
+    /** Each execution consumes one use. A live call's bound closure carries its
+     * admission; it is never resumed from a durable reservation or sent to code.
+     * Subsequent actions still check current authority, not cached permission. */
+    const execution = (taskId, preparationId, pkg, phase) => {
+        const params = { pluginId: pkg.manifest.id, digest: pkg.digest,
+            environmentRef: `${taskId}/${preparationId}`, trust: "trusted-local", phase };
+        // This grants the capability to run code without OS effect confinement;
+        // it does not claim that every invocation actually has irreversible effects.
+        const request = { action: "plugin.execute", params, irreversibility: "irreversible" };
+        const reservation = phase === "call" ? undefined : `plugin/${randomUUID()}`;
+        const grantId = store.transaction((tx) => {
+            const env = environment(taskId, preparationId);
+            const grant = tx.listCapabilityGrants(taskId).find((candidate) => Object.entries(params).every(([key, value]) => candidate.parameterBounds[key]?.includes(value))
+                && (candidate.scope.taskId === undefined || candidate.scope.taskId === taskId)
+                && candidate.scope.projectIds === undefined && candidate.scope.repositories === undefined
+                && candidate.scope.packages === undefined
+                && (candidate.scope.homePath === undefined || candidate.scope.homePath === env.directory.path)
+                && checkGrant(candidate, request, new Date()).allowed);
+            if (!grant)
+                throw new Error(`Explicit trusted-local execution grant unavailable (${phase}); pluginId=${params.pluginId}, digest=${params.digest}, environmentRef=${params.environmentRef}.`);
+            tx.saveCapabilityGrant(taskId, recordGrantUse(grant, new Date(), reservation));
+            return grant.id;
+        });
+        return () => {
+            environment(taskId, preparationId);
+            const grant = store.listCapabilityGrants(taskId).find((candidate) => candidate.id === grantId);
+            if (!grant || (reservation !== undefined && !grant.useReservations.includes(reservation))
+                || !checkGrant(grant, request, new Date(), { skipUsesCheck: true }).allowed) {
+                throw new Error("Plugin execution authority was revoked.");
+            }
+        };
+    };
+    const prepare = async (taskId, preparationId, pkg, phase, executionInput = pkg, admittedExecution) => {
+        if (pkg.manifest.kind === "declarative") {
+            const implementation = interpretPlugin(pkg);
+            const release = retainEnvironment(taskId, preparationId);
+            return { implementation, dispose: async () => { release(); } };
+        }
+        const check = admittedExecution ?? execution(taskId, preparationId, executionInput, phase);
+        const env = environment(taskId, preparationId);
+        const process = new PluginProcess(env.directory.path);
+        const release = retainEnvironment(taskId, preparationId);
+        const dispose = async () => { try {
+            await process.dispose();
+        }
+        finally {
+            release();
+        } };
+        try {
+            check();
+            await process.load(pkg);
+            check();
+            if (phase === "validate") {
+                await process.test();
+                check();
+            }
+            const implementation = {
+                invoke(name, input, invocation) {
+                    const checkCall = execution(taskId, preparationId, pkg, "call");
+                    return process.invoke(name, input, invocation, checkCall);
+                }
+            };
+            return { implementation, dispose };
+        }
+        catch (error) {
+            try {
+                await dispose();
+            }
+            catch (cleanup) {
+                throw new AggregateError([error, cleanup], "Plugin initialization and candidate cleanup failed.");
+            }
+            throw error;
+        }
+    };
+    return {
+        current: inspect,
+        list(taskId) {
+            return store.transaction(() => store.listPluginIntents(taskId)
+                .sort((left, right) => left.pluginId.localeCompare(right.pluginId))
+                .map((intent) => inspect(taskId, intent.pluginId)));
+        },
+        assertEnvironmentUnused(taskId, preparationId) {
+            if ([...environmentUsers.values()].some((owner) => owner.taskId === taskId && owner.preparationId === preparationId)) {
+                throw new Error("Environment has live plugin references; disable and drain its plugins or finish validation first.");
+            }
+        },
+        scan(taskId, preparationId, directory) {
+            const { path } = packageDirectory(taskId, preparationId, directory);
+            const pkg = readPluginPackage(path, false);
+            return { directory: path, preparationId, digest: pkg.digest, manifest: pkg.manifest,
+                files: Object.keys(pkg.files), executedAuthorCode: false };
+        },
+        create(taskId, preparationId, id, kind) {
+            if (!/^[a-z][a-z0-9-]*$/u.test(id) || !["declarative", "trusted-local"].includes(kind))
+                throw new Error("Invalid plugin template.");
+            const env = environment(taskId, preparationId);
+            const directory = join(env.directory.path, id);
+            mkdirSync(directory, { mode: 0o700 }); // Never overwrite an author's directory.
+            const name = `${id}.echo`;
+            const manifest = {
+                id, version: "1.0.0", apiVersion: "1", kind, entry: kind === "declarative" ? "entry.json" : "entry.mjs",
+                capabilities: [{ name, contractVersion: "1", summary: "Return JSON input.", inputSchema: {}, outputSchema: {},
+                        effect: "query", requiredPermissions: [] }], required: [], permissions: [], reloadMode: "manual"
+            };
+            writeFileSync(join(directory, "plugin.json"), JSON.stringify(manifest, null, 2) + "\n", { flag: "wx", mode: 0o600 });
+            writeFileSync(join(directory, manifest.entry), kind === "declarative"
+                ? JSON.stringify({ [name]: { type: "echo" } }, null, 2) + "\n"
+                : `export function initialize() {\n  return { handlers: { ${JSON.stringify(name)}: async (input) => input }, dispose() {} };\n}\nexport function selfTest() { return true; }\n`, { flag: "wx", mode: 0o600 });
+            return { directory, preparationId, kind, executedAuthorCode: false };
+        },
+        async validate(context, preparationId, directory) {
+            const taskId = context.targetId;
+            const { env, path } = packageDirectory(taskId, preparationId, directory);
+            const source = readPluginPackage(path, false);
+            registry.checkRegistration(context, descriptors(taskId, source, refFor(taskId, source)));
+            const checks = ["data-only manifest/schema/namespace/permissions/dependencies"];
+            let pkg = source;
+            if (source.manifest.build) {
+                const check = execution(taskId, preparationId, source, "build");
+                const [script, ...args] = source.manifest.build;
+                packagePath(script);
+                if (!Object.hasOwn(source.files, script))
+                    throw new Error("Build script must be inside the captured source package.");
+                const buildDirectory = mkdtempSync(join(env.directory.path, ".plugin-build-"));
+                const release = retainEnvironment(taskId, preparationId);
+                try {
+                    for (const [file, content] of Object.entries(source.files)) {
+                        const target = join(buildDirectory, file);
+                        mkdirSync(dirname(target), { recursive: true });
+                        writeFileSync(target, content, { flag: "wx", mode: 0o600 });
+                    }
+                    check();
+                    await execute(process.execPath, [join(buildDirectory, script), ...args], {
+                        cwd: buildDirectory, env: pluginProcessEnvironment(buildDirectory),
+                        timeout: 30_000, maxBuffer: 64 * 1024
+                    });
+                    check();
+                    pkg = readPluginPackage(buildDirectory);
+                    checks.push(`build cwd=${buildDirectory}; executable=${process.execPath}; argv=${JSON.stringify(source.manifest.build)}; exit=0`);
+                }
+                finally {
+                    try {
+                        if (realpathSync(buildDirectory) !== buildDirectory)
+                            throw new Error("Build directory identity changed; retained for inspection.");
+                        rmSync(buildDirectory, { recursive: true });
+                    }
+                    finally {
+                        release();
+                    }
+                }
+                checks.push("trusted-local Node build completed");
+            }
+            else {
+                if (!Object.hasOwn(source.files, source.manifest.entry))
+                    throw new Error("Plugin entry is missing.");
+                checks.push("no build command; package is directly loadable");
+            }
+            // Builds may change products, not silently replace permissions or contract.
+            if (JSON.stringify(pkg.manifest) !== JSON.stringify(source.manifest))
+                throw new Error("Build changed plugin manifest; inspect and validate explicitly.");
+            registry.checkRegistration(context, descriptors(taskId, pkg, refFor(taskId, pkg)));
+            const candidate = await prepare(taskId, preparationId, pkg, "validate", source);
+            await candidate.dispose();
+            checks.push(pkg.manifest.kind === "declarative" ? "trusted interpreter parsed complete entry" : "child initialize/full contribution set/selfTest/dispose");
+            const current = packageDirectory(taskId, preparationId, directory);
+            if (readPluginPackage(current.path, false).digest !== source.digest)
+                throw new Error("Plugin changed during validation.");
+            registry.checkRegistration(context, descriptors(taskId, pkg, refFor(taskId, pkg)));
+            const validation = {
+                schemaVersion: 1, id: `validation-${randomUUID()}`, taskId, directory: path, preparationId, sourceDigest: source.digest, package: pkg,
+                environment: { ...env.directory, isolation: "trusted-local", node: process.version },
+                checks, createdAt: new Date().toISOString()
+            };
+            store.savePluginValidation(validation);
+            return { ...validation, package: { manifest: pkg.manifest, digest: pkg.digest } };
+        },
+        inspect(taskId, validationId) {
+            const validation = store.getPluginValidation(taskId, validationId);
+            if (!validation)
+                throw new Error("Plugin validation not found in this Task.");
+            const { files: _files, ...pkg } = validation.package;
+            return { ...validation, package: pkg };
+        },
+        async activate(context, validationId) {
+            const taskId = context.targetId;
+            const validation = store.getPluginValidation(taskId, validationId);
+            if (!validation)
+                throw new Error("Plugin validation not found in this Task.");
+            const { package: pkg, preparationId, directory } = validation;
+            const verify = () => {
+                const current = packageDirectory(taskId, preparationId, directory);
+                const expected = validation.environment;
+                if (current.env.directory.device !== expected.device || current.env.directory.inode !== expected.inode
+                    || current.env.directory.path !== expected.path || expected.node !== process.version) {
+                    throw new Error("Validation execution environment changed; validate again.");
+                }
+                if (readPluginPackage(current.path, false).digest !== validation.sourceDigest)
+                    throw new Error("Plugin bytes differ from validated source.");
+            };
+            verify();
+            const ref = refFor(taskId, pkg);
+            const entries = descriptors(taskId, pkg, ref);
+            registry.checkRegistration(context, entries);
+            // Intent is admitted only after input, content, environment, caller and
+            // execution authorization pass. Grant consumption and selection commit
+            // together, before any author initialization or publication.
+            let admittedExecution;
+            const intent = store.transaction(() => {
+                if (pkg.manifest.kind === "trusted-local")
+                    admittedExecution = execution(taskId, preparationId, pkg, "activate");
+                return choose(taskId, pkg.manifest.id, true, validationId);
+            });
+            let candidate;
+            let attached = false;
+            let previous;
+            try {
+                candidate = await prepare(taskId, preparationId, pkg, "activate", pkg, admittedExecution);
+                verify();
+                registry.checkRegistration(context, entries);
+                if (store.getPluginIntent(taskId, pkg.manifest.id)?.revision !== intent.revision) {
+                    throw new Error("Plugin activation superseded by another explicit management action.");
+                }
+                const implementation = candidate.implementation;
+                host.attach(ref, {
+                    invoke: (name, input, invocation) => {
+                        environment(taskId, preparationId);
+                        return implementation.invoke(name, input, invocation);
+                    }
+                }, [candidate.dispose]);
+                attached = true;
+                previous = active.get(ref.id);
+                registry.register(entries);
+                active.set(ref.id, { ref, validationId });
+            }
+            catch (error) {
+                let failure = error;
+                try {
+                    if (attached)
+                        await host.detach(ref);
+                    else
+                        await candidate?.dispose();
+                }
+                catch (cleanup) {
+                    failure = new Error(`${error instanceof Error ? error.message : String(error)}; candidate cleanup failed: ${String(cleanup)}`);
+                }
+                throw fail(intent, failure);
+            }
+            // Publication has committed. A later diagnostic/read failure must never
+            // enter candidate rollback or detach the new selected implementation.
+            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) });
+                });
+            }
+            return { provider: ref, validationId, digest: pkg.digest, capabilities: entries.map((entry) => entry.name),
+                lifetime: "current-controller", previousDraining: previous?.ref, ...inspect(taskId, pkg.manifest.id) };
+        },
+        async disable(taskId, pluginId) {
+            validatePluginId(pluginId);
+            const key = keyFor(taskId, pluginId);
+            // A failed commit must leave the currently selected implementation alone.
+            const intent = choose(taskId, pluginId, false);
+            const current = active.get(key);
+            if (!current)
+                return { disabled: true, providerId: key, ...inspect(taskId, pluginId) };
+            registry.disable(key);
+            active.delete(key);
+            try {
+                await host.detach(current.ref);
+            }
+            catch (error) {
+                throw fail(intent, new Error(`Plugin disabled; owned cleanup failed: ${error instanceof Error ? error.message : String(error)}`));
+            }
+            return { disabled: true, provider: current.ref, drained: true, ...inspect(taskId, pluginId) };
+        }
+    };
+}

package/dist/profile/agentProfile.js

@@ -75,7 +75,7 @@ export function builtinAgentProfileInputs() {
         {
             id: "reviewer",
             description: "Review one candidate against the user's core outcome, supported behavior, and direct evidence.",
-            instructions: "Start from user intent and acceptance criteria. Inspect the complete relevant change and report only reachable, material, actionable problems with direct evidence. Separate defects from verification gaps, and prefer the smallest sufficient correction. Follow the bound Project's Policy and Knowledge for build, test, migration, release, and review expectations; do not import rules from another Project or Task. For normal software delivery, review the frozen Task result as one final ReviewRound rather than inventing a per-WorkItem protocol unless the Project Policy explicitly requires one. A Task-final Round has no synthetic WorkItem anchor, and the Reviewer Session and physical workspace continue across changed-head Rounds without reusing an earlier verdict. The current Turn's frozen candidate remains the only scope even if Task main advances. For Delta Recheck, return equivalent-and-accepted, finding, or requires-full-review with explicit reasoning; never create the next Round. Do not turn speculative or extreme edge cases into new state, retries, fallbacks, or protocol. In the Review workspace you may edit source or tests, run local checks, and optionally commit diagnostic evidence. Never push, integrate, mutate Task state, touch another workspace or stable checkout, or write the real Yui control-plane home. End the Provider turn with complete findings, checks actually run, uncertainty, and bounded next actions; Yui preserves the full free-form report automatically. Expose evidence and options to the Leader, who decides.",
+            instructions: "Start from user intent and acceptance criteria. Inspect the complete relevant change and report only reachable, material, actionable problems with direct evidence. Separate defects from verification gaps, and prefer the smallest sufficient correction. Follow the bound Project's Policy and Knowledge for build, test, migration, release, and review expectations; do not import rules from another Project or Task. For normal software delivery, review the frozen Task result as one final ReviewRound rather than inventing a per-WorkItem protocol unless the Project Policy explicitly requires one. A Task-final Round has no synthetic WorkItem anchor, and the Reviewer Session and physical workspace continue across changed-head Rounds without reusing an earlier verdict. The current AgentRun's frozen candidate remains the only scope even if Task main advances. For Delta Recheck, return equivalent-and-accepted, finding, or requires-full-review with explicit reasoning; never create the next Round. Do not turn speculative or extreme edge cases into new state, retries, fallbacks, or protocol. In the Review workspace you may edit source or tests, run local checks, and optionally commit diagnostic evidence. Never push, integrate, mutate Task state, touch another workspace or stable checkout, or write the real Yui control-plane home. End the Provider turn with complete findings, checks actually run, uncertainty, and bounded next actions; Yui preserves the full free-form report automatically. Expose evidence and options to the Leader, who decides.",
             defaultAccess: "write",
             runtime: { source: "global-worker" }
         }

package/dist/repository/gitWorkspace.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { lstat, mkdir, realpath, rm } from "node:fs/promises";
+import { lstat, mkdir, readFile, realpath, rm } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { promisify } from "node:util";
 const executeFile = promisify(execFile);
@@ -688,7 +688,8 @@ export class NodeGitWorkspace {
             repositoryPath: input.repositoryPath,
             container: input.container,
             identity: integrationWorktreeIdentity(input.taskSegment, input.integrationId),
-            baseRef: input.baseRef
+            baseRef: input.baseRef,
+            allowRebase: true
         });
     }
     async #ensureManagedWorktree(input) {
@@ -703,7 +704,7 @@ export class NodeGitWorkspace {
             // original base branch/tag is later deleted.
             const project = await this.inspect(input.repositoryPath);
             await assertOwnedWorktree(project, container, path);
-            await assertExpectedBranch(path, identity.branch);
+            await assertExpectedBranch(path, identity.branch, input.allowRebase);
             const head = await gitLine([
                 "-C", path, "rev-parse", "--verify", "--end-of-options", "HEAD^{commit}"
             ]);
@@ -917,7 +918,28 @@ function gitRefSegment(identity) {
     const digest = createHash("sha256").update(identity).digest("hex").slice(0, 24);
     return `encoded-${digest}`;
 }
-async function assertExpectedBranch(path, expected) {
+async function assertExpectedBranch(path, expected, allowRebase = false) {
+    if (allowRebase && !await gitSucceeds(["-C", path, "symbolic-ref", "--quiet", "HEAD"])) {
+        // Rebase temporarily detaches HEAD. Git's per-worktree metadata must still
+        // identify this exact Integration branch; unrelated detachment is invalid.
+        for (const backend of ["rebase-merge", "rebase-apply"]) {
+            const headNamePath = await gitLine(["-C", path, "rev-parse", "--path-format=absolute",
+                "--git-path", `${backend}/head-name`]);
+            let headName;
+            try {
+                headName = (await readFile(headNamePath, "utf8")).trim();
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            if (headName === `refs/heads/${expected}`)
+                return;
+            throw new Error(`Managed worktree is rebasing an unexpected branch: ${headName}.`);
+        }
+        throw new Error("Managed worktree has detached HEAD without its expected rebase.");
+    }
     const branch = await gitLine(["-C", path, "symbolic-ref", "--short", "HEAD"]);
     if (branch !== expected) {
         throw new Error(`Managed worktree is on an unexpected branch: ${branch}.`);

package/dist/repository/project.js

@@ -8,7 +8,7 @@ export function managedProjectPath(home, projectId) {
 export function createProject(id, name, path, branches, now, metadata = {}) {
     const timestamp = now.toISOString();
     return validateProject({
-        schemaVersion: 5,
+        schemaVersion: 6,
         id: requireIdentity(id, "Project id"),
         name: validateProjectName(name),
         aliases: normalizeAliases(metadata.aliases ?? [], name),
@@ -21,6 +21,8 @@ export function createProject(id, name, path, branches, now, metadata = {}) {
         developmentBranch: requireGitRef(branches.development, "Project development branch"),
         status: "active",
         knowledge: [],
+        resourceRefs: [],
+        defaultCapabilityProviders: {},
         knowledgeProposals: [],
         createdAt: timestamp,
         updatedAt: timestamp
@@ -31,7 +33,7 @@ export function validateProjectName(value) {
 }
 /**
  * Soft-retire a Project: mark it retired and record the audit trail. The
- * catalog record, checkout, and every historical Task/Turn/Review/Integration/
+ * catalog record, checkout, and every historical Task/AgentRun/Review/Integration/
  * Publication reference are retained. Retiring an already-retired Project
  * fails closed; a retired Project must be deleted (or kept) as-is.
  */
@@ -276,8 +278,21 @@ export function assertProjectCatalog(projects) {
     }
 }
 export function validateProject(project) {
-    if (project.schemaVersion !== 5) {
-        throw new Error("Project must use schemaVersion 5.");
+    if (project.schemaVersion !== 6) {
+        throw new Error("Project must use schemaVersion 6.");
+    }
+    if (!Array.isArray(project.resourceRefs))
+        throw new Error("Project resourceRefs must be an array.");
+    for (const id of project.resourceRefs)
+        requireIdentity(id, "Project resource");
+    if (new Set(project.resourceRefs).size !== project.resourceRefs.length)
+        throw new Error("Duplicate Project resource.");
+    if (!project.defaultCapabilityProviders || typeof project.defaultCapabilityProviders !== "object"
+        || Array.isArray(project.defaultCapabilityProviders))
+        throw new Error("Invalid Project capability defaults.");
+    for (const [name, provider] of Object.entries(project.defaultCapabilityProviders)) {
+        requireText(name, "Capability name");
+        requireText(provider, "Capability provider reference");
     }
     requireIdentity(project.id, "Project id");
     requireIdentity(project.name, "Project name");

package/dist/repository/taskBaseFreshness.js

@@ -61,10 +61,10 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
     const task = requireTask(store, taskId);
     const git = options.git ?? newGitWorkspace();
     const workspace = store.getTaskWorkspace(taskId);
-    // Collect active Turn workspace snapshots once so every Project entry can
-    // report whether a live Turn is pinned to a different commit.
-    const activeTurns = store.listTurns(taskId)
-        .filter((turn) => turn.status === "active" && turn.workspace !== undefined);
+    // Collect active AgentRun workspace snapshots once so every Project entry can
+    // report whether a live AgentRun is pinned to a different commit.
+    const activeRuns = store.listRuns(taskId)
+        .filter((run) => run.status === "active" && run.workspace !== undefined);
     const entries = await Promise.all(task.projectBindings.map(async (binding) => {
         const project = requireProject(store, binding.projectId);
         const entry = workspace === null ? undefined : workspaceProjectEntry(workspace, project.id);
@@ -77,12 +77,12 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
         catch {
             physicalHead = undefined;
         }
-        // Find the first active Turn whose workspace snapshot covers this Project.
-        const turnSnapshot = activeTurns.find((turn) => {
-            if (turn.workspace === undefined)
+        // Find the first active AgentRun whose workspace snapshot covers this Project.
+        const runSnapshot = activeRuns.find((run) => {
+            if (run.workspace === undefined)
                 return false;
-            const turnEntry = workspaceProjectEntry(turn.workspace, project.id);
-            return turnEntry !== undefined;
+            const runEntry = workspaceProjectEntry(run.workspace, project.id);
+            return runEntry !== undefined;
         });
         const provenance = latestBaseProvenance(store.listEvents(taskId), project.id);
         const tracked = await resolveTracked(git, project, workspacePath, options.refresh === true);
@@ -99,11 +99,11 @@ export async function inspectTaskBaseFreshness(taskId, store, options = {}) {
             workspacePath,
             workspaceClean,
             ...(physicalHead === undefined ? {} : { physicalHead }),
-            ...(turnSnapshot?.workspace === undefined
+            ...(runSnapshot?.workspace === undefined
                 ? {}
                 : {
-                    turnSnapshotCommit: workspaceProjectEntry(turnSnapshot.workspace, project.id)?.baseCommit,
-                    turnSnapshotId: turnSnapshot.id
+                    runSnapshotCommit: workspaceProjectEntry(runSnapshot.workspace, project.id)?.baseCommit,
+                    runSnapshotId: runSnapshot.id
                 }),
             ...(tracked === undefined ? {} : {
                 trackedRef: tracked.ref,
@@ -161,7 +161,7 @@ export function renderTaskBaseFreshnessReport(report) {
         `Task base freshness: ${report.taskId} (source: ${report.refreshed ? "remote refresh" : "local tracking"})`
     ];
     for (const entry of report.entries) {
-        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  physical HEAD: ${entry.physicalHead ?? "-"}`, `  Turn snapshot: ${entry.turnSnapshotCommit ?? "-"}${entry.turnSnapshotId === undefined ? "" : ` (${entry.turnSnapshotId})`}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
+        lines.push(`- ${entry.directory}: ${entry.projectId} @ ${entry.baseCommit}`, `  status: ${entry.status}; workspace: ${entry.workspaceClean === null ? "unknown" : entry.workspaceClean ? "clean" : "dirty"}`, `  physical HEAD: ${entry.physicalHead ?? "-"}`, `  AgentRun snapshot: ${entry.runSnapshotCommit ?? "-"}${entry.runSnapshotId === undefined ? "" : ` (${entry.runSnapshotId})`}`, `  observed remote: ${entry.observedRemoteUrl ?? "-"}`, `  tracked: ${entry.trackedCommit ?? "-"}${entry.trackedRef === undefined ? "" : ` (${entry.trackedRef})`}`, `  observed: ${entry.observedTrackingCommit ?? "-"}${entry.observedAt === undefined ? "" : ` at ${entry.observedAt}`}`);
         if (entry.risk !== undefined)
             lines.push(`  risk: ${entry.risk}`);
         if (entry.error !== undefined)