@nowcrew/daemon 0.6.37 → 0.6.39

package/dist/agent-ability/materializer.js

@@ -15,7 +15,7 @@ const isRealDirectory = (path) => lstat(path)
 const repositoryKey = (url) => createHash("sha256").update(url).digest("hex");
 const posixPath = (value) => value.split(sep).join("/");
 const sameSnapshot = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-const readonlyTree = async (root) => {
+const readonlyTree = async (root, options = {}) => {
     const entries = await readdir(root, { withFileTypes: true });
     for (const entry of entries) {
         const path = join(root, entry.name);
@@ -28,7 +28,8 @@ const readonlyTree = async (root) => {
             await chmod(path, current.mode & 0o111 ? 0o555 : 0o444);
         }
     }
-    await chmod(root, 0o555);
+    // Keep the training root renameable on macOS; its children still carry the package ownership mode.
+    await chmod(root, options.rootWritable === true ? 0o700 : 0o555);
 };
 const writableTree = async (root) => {
     const info = await lstat(root);
@@ -42,6 +43,44 @@ const writableTree = async (root) => {
     for (const entry of await readdir(root))
         await writableTree(join(root, entry));
 };
+const writableDirectories = async (root) => {
+    const info = await lstat(root);
+    if (info.isSymbolicLink() || !info.isDirectory())
+        return;
+    await chmod(root, 0o700);
+    for (const entry of await readdir(root))
+        await writableDirectories(join(root, entry));
+};
+const copyMissingEntries = async (source, target) => {
+    const sourceInfo = await lstat(source).catch(() => null);
+    if (sourceInfo === null || sourceInfo.isSymbolicLink() || !sourceInfo.isDirectory())
+        return;
+    await mkdir(target, { recursive: true });
+    for (const entry of await readdir(source, { withFileTypes: true })) {
+        const sourceEntry = join(source, entry.name);
+        const targetEntry = join(target, entry.name);
+        if (await exists(targetEntry)) {
+            if (entry.isDirectory() && await isRealDirectory(targetEntry)) {
+                await copyMissingEntries(sourceEntry, targetEntry);
+            }
+            continue;
+        }
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory()) {
+            await mkdir(targetEntry, { recursive: true });
+            await copyMissingEntries(sourceEntry, targetEntry);
+            continue;
+        }
+        const sourceEntryInfo = await lstat(sourceEntry);
+        // Read-only files belong to the package, so a removed package file must not
+        // be mistaken for runtime state during a later Release refresh.
+        if ((sourceEntryInfo.mode & 0o222) === 0)
+            continue;
+        await cp(sourceEntry, targetEntry, { recursive: true, preserveTimestamps: true });
+        await writableTree(targetEntry);
+    }
+};
 const removeManagedTree = async (root) => {
     if (!await exists(root))
         return;
@@ -271,14 +310,17 @@ const finishTrainingRestore = async (agentRoot) => {
     const hasRollback = await assertManagedTrainingTreeIfPresent(rollbackRoot, "ability_training_rollback_invalid");
     const hasDiscard = await assertManagedTrainingTreeIfPresent(discardRoot, "ability_training_discard_invalid");
     if (hasTraining && hasRollback && !hasDiscard) {
+        await chmod(trainingRoot, 0o700);
         await rename(trainingRoot, discardRoot);
         await writeTrainingSwitchJournal(agentRoot, { operation: "restore", phase: "current-moved" });
     }
     if (!await exists(trainingRoot) && await exists(rollbackRoot)) {
+        await chmod(rollbackRoot, 0o700);
         await rename(rollbackRoot, trainingRoot);
         await writeTrainingSwitchJournal(agentRoot, { operation: "restore", phase: "restored" });
     }
     if (!await exists(trainingRoot) && !await exists(rollbackRoot) && await exists(discardRoot)) {
+        await chmod(discardRoot, 0o700);
         await rename(discardRoot, trainingRoot);
     }
     if (!await exists(trainingRoot))
@@ -304,9 +346,11 @@ const recoverTrainingSwitch = async (agentRoot) => {
         await removeManagedTree(staging);
     }
     else if (await exists(staging)) {
+        await chmod(staging, 0o700);
         await rename(staging, trainingRoot);
     }
     else if (await exists(rollbackRoot)) {
+        await chmod(rollbackRoot, 0o700);
         await rename(rollbackRoot, trainingRoot);
     }
     else {
@@ -327,6 +371,9 @@ const switchTrainingDirectory = async (agentRoot, staging) => {
     });
     try {
         if (await exists(trainingRoot)) {
+            // Older materializer versions made the root itself read-only. macOS requires
+            // a writable source directory for rename, while its package children stay protected.
+            await chmod(trainingRoot, 0o700);
             await rename(trainingRoot, rollbackRoot);
             await writeTrainingSwitchJournal(agentRoot, {
                 operation: "install", phase: "previous-renamed", stagingName: basename(staging),
@@ -489,11 +536,18 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
             })),
             evals: evalPaths.map((path) => `training/evals/${layerRelativePath(path, "evals")}`),
         }, null, 2), { encoding: "utf8", mode: 0o600 });
-        await readonlyTree(staging);
+        await readonlyTree(staging, { rootWritable: true });
         for (const asset of ability.workspace) {
             if (asset.mode === "managed-copy") {
                 await writableTree(join(staging, "workspace", abilityWorkspaceProjectionPath(asset.target)));
             }
+            else if (asset.mode === "managed-runtime") {
+                const target = join(staging, "workspace", abilityWorkspaceProjectionPath(asset.target));
+                await writableDirectories(target);
+                const previous = join(trainingRoot, "workspace", abilityWorkspaceProjectionPath(asset.target));
+                if (previousCatalog !== null && await exists(previous))
+                    await copyMissingEntries(previous, target);
+            }
         }
         await switchTrainingDirectory(agentRoot, staging);
     }

package/dist/agent-ability/resolver.js

@@ -6,6 +6,7 @@ import { promisify } from "node:util";
 import { parse } from "yaml";
 import { z } from "zod";
 import { abilityWorkspaceProjectionPath, DaemonAbilityLockSchema, DaemonAbilityManifestSchema, matchesAbilityBranch, } from "./types.js";
+import { PROJECT_MANIFEST_SOURCE_PATH, ProjectDependencyManifestSchema, } from "../project-dependency-manifest.js";
 const runFile = promisify(execFile);
 const MAX_FILES = 5_000;
 const MAX_TOTAL_BYTES = 25 * 1024 * 1024;
@@ -76,6 +77,22 @@ const git = async (args, cwd) => {
     });
     return result.stdout.trim();
 };
+export const projectDependencyIds = (files, manifest) => {
+    const assets = manifest.spec.workspace.assets.filter((asset) => asset.source === PROJECT_MANIFEST_SOURCE_PATH);
+    if (assets.length === 0)
+        return Object.freeze([]);
+    if (assets.length > 1)
+        throw new Error("ability_project_dependency_manifest_duplicate");
+    const file = files.find((candidate) => candidate.path === PROJECT_MANIFEST_SOURCE_PATH);
+    if (file === undefined)
+        throw new Error("ability_project_dependency_manifest_missing");
+    try {
+        return Object.freeze(ProjectDependencyManifestSchema.parse(parse(file.content.toString("utf8"))).projects.map((project) => project.id));
+    }
+    catch {
+        throw new Error("ability_project_dependency_manifest_invalid");
+    }
+};
 export const collectAbilityFiles = async (root) => {
     const files = [];
     let totalBytes = 0;
@@ -404,6 +421,7 @@ export async function resolveAbilityRelease(agentsRoot, command) {
     if (memory.reduce((bytes, entry) => bytes + Buffer.byteLength(entry.content, "utf8"), 0) > MAX_MEMORY_BYTES) {
         throw new Error("ability_memory_size_exceeded");
     }
+    const projectDependencies = projectDependencyIds(files, manifest);
     return {
         branch: resolved.branch, rootCommit: resolved.commit, treeDigest: resolved.treeDigest,
         artifactDigest, schemaVersion: manifest.apiVersion, manifest, lock, assetSummary,
@@ -419,6 +437,7 @@ export async function resolveAbilityRelease(agentsRoot, command) {
                 mode: skill.mode,
             })),
             workspace: manifest.spec.workspace.assets, evals: manifest.spec.evals.cases,
+            projectDependencies,
         },
     };
 }

package/dist/agent-ability/types.js

@@ -48,7 +48,7 @@ export function matchesAbilityBranch(glob, branch) {
     }
     return new RegExp(`${pattern}$`, "u").test(branch);
 }
-const ModeSchema = z.enum(["managed-readonly", "managed-copy", "overlay", "generated"]);
+const ModeSchema = z.enum(["managed-readonly", "managed-copy", "managed-runtime", "overlay", "generated"]);
 const LocalSkillSchema = z.object({ type: z.literal("local"), path: SafeAbilityPathSchema, catalog: SafeAbilityPathSchema.optional() }).strict();
 const GitSkillSchema = z.object({
     type: z.literal("git"), url: AbilityRepositoryUrlSchema, ref: z.string().min(1).max(256), path: SafeAbilityPathSchema,
@@ -80,8 +80,8 @@ export const DaemonAbilityManifestSchema = z.object({
             minNowCrewVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),
         }).strict().optional(),
         permissions: z.object({
-            network: z.literal("declared-only"), executableAssets: z.literal("skill-declared-only"),
-            secrets: z.literal("runtime-only"), productionWrites: z.literal("human-confirmed").optional(),
+            network: z.literal("declared-only"), executableAssets: z.enum(["skill-declared-only", "declared-only"]),
+            secrets: z.enum(["runtime-only", "controlled-memory"]), productionWrites: z.literal("human-confirmed").optional(),
         }).strict(),
         rollout: z.object({ mode: z.enum(["manual", "auto_after_gates", "scheduled", "pinned"]), canaryExecutions: z.number().int().min(0).max(100), rollbackOnGateFailure: z.boolean().optional() }).strict(),
     }).strict(),
@@ -95,6 +95,16 @@ export const DaemonAbilityManifestSchema = z.object({
     unique(manifest.spec.skills.map((skill) => skill.name.replace(/[^A-Za-z0-9._-]/gu, "_")), ["spec", "skills"], "Skill projection");
     unique(manifest.spec.skills.map((skill) => skill.mount), ["spec", "skills"], "Skill mount");
     unique(manifest.spec.workspace.assets.map((asset) => asset.target), ["spec", "workspace", "assets"], "Workspace target");
+    for (const asset of manifest.spec.workspace.assets) {
+        if (asset.source === "workspace/project-dependencies.yaml"
+            && asset.target !== "training/workspace/project-dependencies.yaml") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["spec", "workspace", "assets"],
+                message: "project dependency manifest target must be training/workspace/project-dependencies.yaml",
+            });
+        }
+    }
     unique(manifest.spec.evals.cases, ["spec", "evals", "cases"], "Eval case");
 });
 export const DaemonAbilityLockSchema = z.object({

package/dist/execution-runner.js

@@ -18,6 +18,7 @@ import { ProjectSkillRuntimeOwnershipUnverifiedError, } from "./project-skills/r
 import { projectSkillExecutionProjection, projectSkillProjectionErrorCode } from "./project-skills/execution-adapter.js";
 import { redactProjectSkillRuntimeRootError, } from "./project-skills/runtime-launch.js";
 import { createProjectRegistry } from "./project-skills/registry.js";
+import { ProjectDependencyError, } from "./project-dependencies.js";
 import { ProjectContextUnavailableError, resolveProjectContext } from "./project-workspaces/resolver.js";
 import { PROJECT_WORKSPACES_CAPABILITY } from "./machine-info.js";
 import { PROJECT_SKILL_PROJECTION_V2_CAPABILITY } from "./project-skills/types.js";
@@ -333,7 +334,9 @@ function failedCompletion(spec, error, startedAt, finishedAt) {
         ? "queue_timeout"
         : error instanceof ProjectContextUnavailableError
             ? error.code
-            : projectSkillProjectionErrorCode(error) ?? "local_execution_failed";
+            : error instanceof ProjectDependencyError
+                ? error.code
+                : projectSkillProjectionErrorCode(error) ?? "local_execution_failed";
     return ExecutionCompletedSchema.parse({
         type: "execution:completed",
         protocolVersion: 1,
@@ -505,7 +508,31 @@ export async function runExecution(config, input, dependencies) {
                     ? {}
                     : { primaryProjectId: logicalProjectContext.primaryProjectId }),
             };
-            projectContext = await cancellable(resolveProjectContext(projectSnapshot, dependencies.projectWorkspaceRegistry ?? createProjectRegistry(config.agentsRoot)), dependencies.cancellation);
+            const projectWorkspaceRegistry = dependencies.projectWorkspaceRegistry
+                ?? dependencies.projectRegistry
+                ?? createProjectRegistry(config.agentsRoot);
+            if (spec.agent.abilityRelease !== undefined && dependencies.projectDependencies !== undefined) {
+                if (dependencies.abilityRelease !== undefined) {
+                    await cancellable(dependencies.abilityRelease.apply(config.agentsRoot, spec.agent.handle, spec.agent.abilityRelease), dependencies.cancellation);
+                }
+                const preparedProjectDependencies = await cancellable(dependencies.projectDependencies.prepare({
+                    trainingRoot: join(config.agentsRoot, spec.agent.handle, "training"),
+                    projectsRoot: join(config.agentsRoot, "Projects"),
+                    projectIds: projectSnapshot.projectIds,
+                }), dependencies.cancellation);
+                for (const project of preparedProjectDependencies) {
+                    dslog("project_dependencies.prepared", "Training project dependency prepared", {
+                        execution_id: spec.executionId,
+                        agent_handle: spec.agent.handle,
+                        project_id: project.projectId,
+                        project_branch: project.branch,
+                        project_branch_source: project.branchSource,
+                        project_commit: project.resolvedCommit,
+                        project_checkout_mode: project.checkoutMode,
+                    });
+                }
+            }
+            projectContext = await cancellable(resolveProjectContext(projectSnapshot, projectWorkspaceRegistry), dependencies.cancellation);
             sessionContextFingerprint = projectSessionContextFingerprint(spec.runtime.name, projectSnapshot);
         }
         let recalledMemory = "";

package/dist/local-executor.js

@@ -469,6 +469,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             CREW_TOKEN: input.launch.token,
             CREW_CHANNEL: input.channelId,
             CREW_HOME: workspace.dir,
+            // Expose only the training root; ability-specific workspace layout stays
+            // owned by the training package rather than the NowWork daemon.
+            QA_RUNTIME_ROOT: join(workspace.dir, "training"),
             CREW_TASK_DIR: executionWorkspace.runDir,
             CREW_TASK_LOG: executionWorkspace.workLogPath,
             ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),

package/dist/machine-info.js

@@ -23,6 +23,7 @@ import { daemonHome } from "./computer-profile.js";
 export { executableRuntimes } from "./runtime-capabilities.js";
 const execFileP = promisify(execFile);
 export const PROJECT_WORKSPACES_CAPABILITY = "project_workspaces_v1";
+export const TRAINING_PROJECT_DEPENDENCIES_CAPABILITY = "training_project_dependencies_v1";
 export const NATIVE_PROJECT_WORKSPACE_READINESS = Object.freeze({
     resolverReady: true,
     nativeRuntimeAdaptersReady: true,
@@ -40,6 +41,7 @@ export const DAEMON_CAPABILITIES = Object.freeze([
     "execution_agent_memory_mapping_v1",
     "project_skills_v1",
     PROJECT_WORKSPACES_CAPABILITY,
+    TRAINING_PROJECT_DEPENDENCIES_CAPABILITY,
     RUNTIME_HEALTH_PROBE_CAPABILITY,
     "agent_ability_release_v1",
     "agent_ability_workspace_v1",

package/dist/project-dependencies.js

@@ -0,0 +1,254 @@
+import { execFile } from "node:child_process";
+import { lstat, mkdir, readFile, rm } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { parse } from "yaml";
+import { validateAbilityGitHost } from "./agent-ability/resolver.js";
+import { PROJECT_BRANCH, PROJECT_BRANCH_FORBIDDEN, PROJECT_MANIFEST_SOURCE_PATH, ProjectDependencyManifestSchema, } from "./project-dependency-manifest.js";
+const runFile = promisify(execFile);
+const PROJECT_MANIFEST_RELATIVE_PATH = PROJECT_MANIFEST_SOURCE_PATH;
+const PROJECT_MANIFEST_MAX_BYTES = 128 * 1024;
+const GIT_ARGS = ["-c", "core.hooksPath=/dev/null"];
+export { ProjectDependencyManifestSchema } from "./project-dependency-manifest.js";
+export class ProjectDependencyError extends Error {
+    code;
+    detail;
+    projectId;
+    constructor(code, detail = undefined, projectId) {
+        super(code);
+        this.code = code;
+        this.detail = detail;
+        this.projectId = projectId;
+        this.name = "ProjectDependencyError";
+    }
+}
+const gitEnv = () => ({
+    ...process.env,
+    GIT_CONFIG_NOSYSTEM: "1",
+    GIT_CONFIG_GLOBAL: process.platform === "win32" ? "NUL" : "/dev/null",
+    GIT_TERMINAL_PROMPT: "0",
+});
+const defaultGit = {
+    async run(args, cwd) {
+        try {
+            const result = await runFile("git", [...GIT_ARGS, ...args], {
+                ...(cwd === undefined ? {} : { cwd }),
+                env: gitEnv(),
+                timeout: 120_000,
+                maxBuffer: 16 * 1024 * 1024,
+            });
+            return result.stdout.trim();
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new ProjectDependencyError("project_dependency_checkout_failed", detail);
+        }
+    },
+};
+const safeBranchDirectory = (branch) => branch
+    .replaceAll("/", "__")
+    .replace(/[^A-Za-z0-9._-]/gu, "_")
+    .replace(/^[-.]+/u, "_")
+    .slice(0, 128) || "default";
+const projectManifestPath = (trainingRoot) => resolve(trainingRoot, PROJECT_MANIFEST_RELATIVE_PATH);
+const isWithin = (root, target) => {
+    const resolvedRoot = resolve(root);
+    const resolvedTarget = resolve(target);
+    return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(`${resolvedRoot}${sep}`);
+};
+async function readProjectManifest(trainingRoot) {
+    const path = projectManifestPath(trainingRoot);
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw new ProjectDependencyError("project_dependency_manifest_invalid", "cannot read project dependency manifest");
+    }
+    if (Buffer.byteLength(raw, "utf8") > PROJECT_MANIFEST_MAX_BYTES) {
+        throw new ProjectDependencyError("project_dependency_manifest_invalid", "project dependency manifest is too large");
+    }
+    try {
+        return ProjectDependencyManifestSchema.parse(parse(raw));
+    }
+    catch {
+        throw new ProjectDependencyError("project_dependency_manifest_invalid", "project dependency manifest schema is invalid");
+    }
+}
+async function resolveDefaultBranch(git, repo, projectId) {
+    let output;
+    try {
+        output = await git.run(["ls-remote", "--symref", repo, "HEAD"]);
+    }
+    catch (error) {
+        throw new ProjectDependencyError("project_dependency_default_branch_unavailable", `cannot resolve remote default branch for ${projectId}`, projectId);
+    }
+    const branch = output.split(/\r?\n/u)
+        .map((line) => line.match(/^ref:\s+refs\/heads\/([^\s]+)\s+HEAD$/u)?.[1])
+        .find((value) => value !== undefined);
+    if (branch === undefined || !PROJECT_BRANCH.test(branch) || PROJECT_BRANCH_FORBIDDEN.test(branch)) {
+        throw new ProjectDependencyError("project_dependency_default_branch_unavailable", `remote default branch is unavailable for ${projectId}`, projectId);
+    }
+    return branch;
+}
+async function checkoutProject(git, project, branch, target) {
+    const targetInfo = await lstat(target).catch(() => null);
+    if (targetInfo?.isSymbolicLink() || (targetInfo !== null && !targetInfo.isDirectory())) {
+        throw new ProjectDependencyError("project_dependency_checkout_conflict", "checkout target is not a directory", project.id);
+    }
+    const created = targetInfo === null;
+    if (created) {
+        await mkdir(dirname(target), { recursive: true });
+        try {
+            await git.run(["clone", "--single-branch", "--branch", branch, project.repo, target]);
+        }
+        catch (error) {
+            await rm(target, { recursive: true, force: true }).catch(() => { });
+            throw new ProjectDependencyError("project_dependency_checkout_failed", error instanceof Error ? error.message : String(error), project.id);
+        }
+    }
+    else {
+        let origin;
+        try {
+            origin = await git.run(["remote", "get-url", "origin"], target);
+            if (origin !== project.repo) {
+                throw new ProjectDependencyError("project_dependency_checkout_conflict", "checkout origin does not match manifest", project.id);
+            }
+            const dirty = await git.run(["status", "--porcelain"], target);
+            if (dirty.length > 0) {
+                throw new ProjectDependencyError("project_dependency_checkout_dirty", "checkout has local changes", project.id);
+            }
+            await git.run(["fetch", "--no-tags", "origin", branch], target);
+            await git.run(["checkout", "--force", "-B", branch, `origin/${branch}`], target);
+        }
+        catch (error) {
+            if (error instanceof ProjectDependencyError)
+                throw error;
+            throw new ProjectDependencyError("project_dependency_checkout_conflict", `cannot reuse checkout for ${project.id}`, project.id);
+        }
+    }
+    try {
+        return {
+            resolvedCommit: await git.run(["rev-parse", "HEAD"], target),
+            created,
+        };
+    }
+    catch {
+        throw new ProjectDependencyError("project_dependency_checkout_failed", "checkout commit cannot be resolved", project.id);
+    }
+}
+const existingAncestorIsSymlink = async (root, target) => {
+    const resolvedRoot = resolve(root);
+    let current = resolve(target);
+    while (current !== resolvedRoot && isWithin(resolvedRoot, current)) {
+        const info = await lstat(current).catch(() => null);
+        if (info?.isSymbolicLink())
+            return true;
+        current = dirname(current);
+    }
+    const rootInfo = await lstat(resolvedRoot).catch(() => null);
+    return rootInfo?.isSymbolicLink() === true;
+};
+async function ensureRegistered(registry, project, root) {
+    let registrations;
+    try {
+        registrations = await registry.list();
+    }
+    catch {
+        throw new ProjectDependencyError("project_dependency_registration_conflict", `cannot read project registry for ${project.id}`, project.id);
+    }
+    const existing = registrations.find((candidate) => candidate.projectId === project.id);
+    if (existing === undefined) {
+        try {
+            await registry.add(project.id, root);
+        }
+        catch (error) {
+            throw new ProjectDependencyError("project_dependency_registration_conflict", `cannot register project ${project.id}`, project.id);
+        }
+        return;
+    }
+    if (resolve(existing.root) === resolve(root))
+        return;
+    // A manifest branch change intentionally moves the logical project ID to the
+    // new checkout. Keep the old registration if the replacement cannot finish.
+    try {
+        const removed = await registry.remove(project.id);
+        if (!removed) {
+            throw new Error("project registration disappeared before replacement");
+        }
+        try {
+            await registry.add(project.id, root);
+        }
+        catch (error) {
+            await registry.add(project.id, existing.root).catch(() => { });
+            throw error;
+        }
+    }
+    catch {
+        throw new ProjectDependencyError("project_dependency_registration_conflict", `cannot move project ${project.id} registration to the prepared checkout`, project.id);
+    }
+}
+export function createProjectDependencyProvisioner(options) {
+    const git = options.git ?? defaultGit;
+    return {
+        async prepare(input) {
+            const manifest = await readProjectManifest(input.trainingRoot);
+            if (manifest === null || input.projectIds.length === 0)
+                return Object.freeze([]);
+            if (!isWithin(input.trainingRoot, projectManifestPath(input.trainingRoot))) {
+                throw new ProjectDependencyError("project_dependency_manifest_invalid", "project manifest path escapes training root");
+            }
+            const byId = new Map(manifest.projects.map((project) => [project.id, project]));
+            const requested = [...new Set(input.projectIds)];
+            const results = [];
+            for (const projectId of requested) {
+                const project = byId.get(projectId);
+                if (project === undefined) {
+                    throw new ProjectDependencyError("project_dependency_not_declared", `project ${projectId} is not declared by the active training package`, projectId);
+                }
+                try {
+                    validateAbilityGitHost(project.repo);
+                }
+                catch {
+                    throw new ProjectDependencyError("project_dependency_host_not_allowed", "repository host is not allowed", project.id);
+                }
+                const branchSource = project.branch === undefined ? "remote-default" : "manifest";
+                const branch = project.branch ?? await resolveDefaultBranch(git, project.repo, project.id);
+                const root = resolve(input.projectsRoot, project.id, safeBranchDirectory(branch));
+                if (!isWithin(input.projectsRoot, root)) {
+                    throw new ProjectDependencyError("project_dependency_checkout_conflict", "checkout path escapes Projects root", project.id);
+                }
+                if (await existingAncestorIsSymlink(input.projectsRoot, root)) {
+                    throw new ProjectDependencyError("project_dependency_checkout_conflict", "checkout path contains a symbolic link", project.id);
+                }
+                const checkout = await checkoutProject(git, project, branch, root);
+                try {
+                    await ensureRegistered(options.registry, project, root);
+                }
+                catch (error) {
+                    if (checkout.created)
+                        await rm(root, { recursive: true, force: true }).catch(() => { });
+                    throw error;
+                }
+                results.push(Object.freeze({
+                    projectId: project.id,
+                    repo: project.repo,
+                    branch,
+                    branchSource,
+                    resolvedCommit: checkout.resolvedCommit,
+                    checkoutMode: "shared",
+                    localRoot: root,
+                    summary: project.summary,
+                }));
+            }
+            return Object.freeze(results);
+        },
+    };
+}
+export async function listProjectDependencies(trainingRoot) {
+    const manifest = await readProjectManifest(trainingRoot);
+    return Object.freeze(manifest?.projects ?? []);
+}
+export { PROJECT_MANIFEST_RELATIVE_PATH };

package/dist/project-dependency-manifest.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { AbilityRepositoryUrlSchema } from "./agent-ability/types.js";
+import { isProjectId } from "./project-skills/types.js";
+export const PROJECT_MANIFEST_SOURCE_PATH = "workspace/project-dependencies.yaml";
+export const PROJECT_BRANCH = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,255}$/u;
+export const PROJECT_BRANCH_FORBIDDEN = /(?:^|\/)\.\.?(?:\/|$)|[\s\p{Cc}\\]/u;
+export const PROJECT_SUMMARY_MAX_LENGTH = 1_000;
+const ProjectDependencySchema = z.object({
+    id: z.string().min(1).max(64),
+    repo: AbilityRepositoryUrlSchema,
+    branch: z.string().min(1).max(256).optional(),
+    summary: z.string().min(1).max(PROJECT_SUMMARY_MAX_LENGTH),
+}).strict().superRefine((project, ctx) => {
+    if (!isProjectId(project.id)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["id"], message: "invalid project id" });
+    }
+    if (project.branch !== undefined
+        && (!PROJECT_BRANCH.test(project.branch) || PROJECT_BRANCH_FORBIDDEN.test(project.branch))) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["branch"], message: "invalid project branch" });
+    }
+});
+export const ProjectDependencyManifestSchema = z.object({
+    version: z.literal(1),
+    projects: z.array(ProjectDependencySchema).min(1).max(32),
+}).strict().superRefine((manifest, ctx) => {
+    const ids = manifest.projects.map((project) => project.id);
+    if (new Set(ids).size !== ids.length) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["projects"], message: "duplicate project id" });
+    }
+});

package/dist/project-registry-wiring.js

@@ -0,0 +1,29 @@
+import { createProjectDependencyProvisioner } from "./project-dependencies.js";
+import { createProjectRegistry } from "./project-skills/registry.js";
+const writableRegistry = (registry) => {
+    if (registry === undefined)
+        return undefined;
+    const candidate = registry;
+    return typeof candidate.add === "function" && typeof candidate.remove === "function"
+        ? registry
+        : undefined;
+};
+export function createProjectRegistryWiring(agentsRoot, input = {}) {
+    const writableInjectedRegistry = writableRegistry(input.projectWorkspaceRegistry);
+    const projectRegistry = input.projectRegistry
+        ?? writableInjectedRegistry
+        ?? createProjectRegistry(agentsRoot);
+    const projectWorkspaceRegistry = input.projectWorkspaceRegistry ?? projectRegistry;
+    if (input.projectDependencies !== undefined && input.projectRegistry === undefined) {
+        throw new Error("project_dependency_injection_requires_project_registry");
+    }
+    if (input.projectWorkspaceRegistry !== undefined && projectWorkspaceRegistry !== projectRegistry) {
+        throw new Error("project_registry_injection_requires_writable_registry");
+    }
+    return Object.freeze({
+        projectRegistry,
+        projectWorkspaceRegistry,
+        projectDependencyProvisioner: input.projectDependencies
+            ?? createProjectDependencyProvisioner({ registry: projectRegistry }),
+    });
+}

package/dist/serve.js

@@ -35,7 +35,7 @@ import { detectDaemonUpdateEligibility, managedDaemonCapabilities, } from "./dae
 import { createDaemonUpdateController } from "./daemon-update-controller.js";
 import { installExactDaemonUpdate, prepareDaemonRestart } from "./daemon-updater.js";
 import { scheduleServiceRestart } from "./computer-service.js";
-import { createProjectRegistry } from "./project-skills/registry.js";
+import { createProjectRegistryWiring } from "./project-registry-wiring.js";
 import { createProjectSkillsController, } from "./project-skills/controller.js";
 import { PROJECT_SKILLS_CAPABILITY } from "./project-skills/types.js";
 import { createAgentProjectionCoordinator } from "./project-skills/agent-projection-coordinator.js";
@@ -138,6 +138,7 @@ export function serve(config, opts = {}) {
         }
         catch { /* reconnect */ } } });
     const projectionCoordinator = createAgentProjectionCoordinator();
+    const { projectRegistry, projectWorkspaceRegistry, projectDependencyProvisioner } = createProjectRegistryWiring(config.agentsRoot, opts.execution?.dependencies);
     const agentAbilityRuntime = createAgentAbilityRuntime(config.agentsRoot, {
         ...opts.agentAbility,
         coordinator: projectionCoordinator,
@@ -150,7 +151,7 @@ export function serve(config, opts = {}) {
         protectedExecutionIds,
     });
     projectSkillsController = opts.projectSkills?.controller ?? createProjectSkillsController({
-        registry: createProjectRegistry(config.agentsRoot),
+        registry: projectRegistry,
         publish: (frame) => {
             if (!serverCapabilities.has(PROJECT_SKILLS_CAPABILITY))
                 return;
@@ -618,6 +619,8 @@ export function serve(config, opts = {}) {
                         capabilities: capabilities.executionRunner,
                         projectSkills: opts.execution?.dependencies?.projectSkills ?? initializedProjectSkills,
                         abilityRelease: opts.execution?.dependencies?.abilityRelease ?? agentAbilityRuntime.materializer,
+                        projectWorkspaceRegistry,
+                        projectDependencies: projectDependencyProvisioner,
                         ...(agentMemory === undefined ? {} : { agentMemory }),
                         journal: executionJournal,
                         facts: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.37",
+  "version": "0.6.39",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -16,6 +16,14 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
+    "prepublishOnly": "pnpm build && node ../scripts/daemon-release-artifact.mjs --strict-registry",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
     "@nowcrew/cli": "^0.4.13",
@@ -34,12 +42,5 @@
     "tsx": "^4.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.1.0"
-  },
-  "scripts": {
-    "daemon": "pnpm --filter @nowcrew/cli build && tsx src/main.ts",
-    "build": "tsc -p tsconfig.json",
-    "codex-home:migrate": "tsx src/runtimes/codex-home-migration-cli.ts",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
   }
-}
+}