@nowcrew/daemon 0.6.68 → 0.6.70

package/dist/managed-service-startup.js

@@ -14,6 +14,7 @@ export async function assertManagedServiceStartup(input) {
         nodePath: input.nodePath,
         entryPath: input.entryPath,
         profileHome: input.daemonHome,
+        ...(input.environment === undefined ? {} : { environment: input.environment }),
     });
     const readRegistry = input.readManagedServices
         ?? (() => readManagedServiceRegistry({ userHome: input.userHome }));
@@ -42,6 +43,7 @@ export async function assertManagedServiceStartup(input) {
             nodePath: input.nodePath,
             entryPath: input.entryPath,
             profileHome: input.daemonHome,
+            ...(input.environment === undefined ? {} : { environment: input.environment }),
             legacyServiceId: true,
         });
         const legacyDescriptor = await readDescriptor(legacySpec);

package/dist/profile-layout.js

@@ -2,6 +2,10 @@ import { posix, win32 } from "node:path";
 export const PROFILE_LAYOUT_VERSION = 1;
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
 const LOCAL_INSTANCE_NAME = /^[a-z0-9][a-z0-9_-]{0,39}$/u;
+/** Accept the legacy `in` tag at the boundary, but never persist it in a new layout. */
+export function normalizeProfileEnvironment(value) {
+    return value === "in" ? "production" : value;
+}
 export function validateLocalInstanceName(value) {
     const normalized = value.trim().toLowerCase();
     if (!LOCAL_INSTANCE_NAME.test(normalized) || normalized.includes("..")) {
@@ -10,19 +14,21 @@ export function validateLocalInstanceName(value) {
     return normalized;
 }
 export function profileForLocalInstance(environment, localInstanceName) {
-    const profile = `nw-${environment}-${validateLocalInstanceName(localInstanceName)}`;
+    const canonicalEnvironment = normalizeProfileEnvironment(environment);
+    const profile = `nw-${canonicalEnvironment}-${validateLocalInstanceName(localInstanceName)}`;
     if (!PROFILE_NAME.test(profile))
         throw new Error("derived daemon profile exceeds 48 characters");
     return profile;
 }
 export function profileLayout(input) {
+    const environment = normalizeProfileEnvironment(input.environment);
     const localInstanceName = validateLocalInstanceName(input.localInstanceName);
-    const profile = profileForLocalInstance(input.environment, localInstanceName);
+    const profile = profileForLocalInstance(environment, localInstanceName);
     const paths = input.platform === "win32" ? win32 : posix;
-    const base = `${input.environment}-${localInstanceName}`;
+    const base = `${environment}-${localInstanceName}`;
     return Object.freeze({
         layoutVersion: PROFILE_LAYOUT_VERSION,
-        environment: input.environment,
+        environment,
         localInstanceName,
         profile,
         daemonHome: paths.join(input.userHome, ".crew", `daemon-${base}`),

package/dist/project-dependencies.js

@@ -1,10 +1,12 @@
 import { execFile } from "node:child_process";
-import { lstat, mkdir, readFile, rm } from "node:fs/promises";
+import { lstat, mkdir, readFile, rm, writeFile } 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 { dslog } from "./slog.js";
+import { ProjectDependencyLockTimeoutError, withProjectDependencyLock, } from "./project-dependency-lock.js";
+import { normalizeRepositoryIdentity, worktreeDirectoryName } from "./repository-identity.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;
@@ -14,12 +16,12 @@ export { ProjectDependencyManifestSchema } from "./project-dependency-manifest.j
 export class ProjectDependencyError extends Error {
     code;
     detail;
-    projectId;
-    constructor(code, detail = undefined, projectId) {
+    repositoryKey;
+    constructor(code, detail, repositoryKey) {
         super(code);
         this.code = code;
         this.detail = detail;
-        this.projectId = projectId;
+        this.repositoryKey = repositoryKey;
         this.name = "ProjectDependencyError";
     }
 }
@@ -46,16 +48,23 @@ const defaultGit = {
         }
     },
 };
-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}`);
+    return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + sep);
+};
+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 readProjectManifest(trainingRoot) {
     const path = projectManifestPath(trainingRoot);
@@ -78,127 +87,127 @@ async function readProjectManifest(trainingRoot) {
         throw new ProjectDependencyError("project_dependency_manifest_invalid", "project dependency manifest schema is invalid");
     }
 }
-async function resolveDefaultBranch(git, repo, projectId) {
+async function resolveDefaultBranch(git, repo, repositoryKey) {
     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);
+    catch {
+        throw new ProjectDependencyError("project_dependency_default_branch_unavailable", "cannot resolve remote default branch", repositoryKey);
     }
     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);
+        throw new ProjectDependencyError("project_dependency_default_branch_unavailable", "remote default branch is unavailable", repositoryKey);
     }
     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);
+async function ensureWorktreeExclude(mainRoot) {
+    const excludePath = join(mainRoot, ".git", "info", "exclude");
+    const current = await readFile(excludePath, "utf8").catch(() => "");
+    if (current.split(/\r?\n/u).includes(".worktrees/"))
+        return;
+    const suffix = current.length === 0 || current.endsWith("\n") ? "" : "\n";
+    await writeFile(excludePath, current + suffix + ".worktrees\n", "utf8");
+}
+async function ensureMainClone(git, repo, repositoryKey, reposRoot) {
+    const mainRoot = resolve(reposRoot, repositoryKey);
+    if (!isWithin(reposRoot, mainRoot) || await existingAncestorIsSymlink(reposRoot, mainRoot)) {
+        throw new ProjectDependencyError("project_dependency_checkout_conflict", "repository path is unsafe", repositoryKey);
+    }
+    const info = await lstat(mainRoot).catch(() => null);
+    if (info?.isSymbolicLink() || (info !== null && !info.isDirectory())) {
+        throw new ProjectDependencyError("project_dependency_checkout_conflict", "main clone is not a directory", repositoryKey);
     }
-    const created = targetInfo === null;
-    if (created) {
-        await mkdir(dirname(target), { recursive: true });
+    if (info === null) {
+        await mkdir(dirname(mainRoot), { recursive: true });
         try {
-            await git.run(["clone", "--single-branch", "--branch", branch, project.repo, target]);
+            await git.run(["clone", "--no-checkout", repo, mainRoot]);
         }
-        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);
+        catch {
+            await rm(mainRoot, { recursive: true, force: true }).catch(() => { });
+            throw new ProjectDependencyError("project_dependency_checkout_failed", "main clone failed", repositoryKey);
         }
     }
     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 origin = await git.run(["remote", "get-url", "origin"], mainRoot);
+            if (normalizeRepositoryIdentity(origin).repositoryKey !== repositoryKey) {
+                throw new ProjectDependencyError("project_dependency_checkout_conflict", "clone origin does not match repo", repositoryKey);
             }
-            const dirty = await git.run(["status", "--porcelain"], target);
+            await ensureWorktreeExclude(mainRoot);
+            const dirty = await git.run(["status", "--porcelain"], mainRoot);
             if (dirty.length > 0) {
-                throw new ProjectDependencyError("project_dependency_checkout_dirty", "checkout has local changes", project.id);
+                throw new ProjectDependencyError("project_dependency_checkout_dirty", "main clone has local changes", repositoryKey);
             }
-            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);
+            throw new ProjectDependencyError("project_dependency_checkout_conflict", "cannot inspect main clone", repositoryKey);
         }
     }
+    await ensureWorktreeExclude(mainRoot);
+    return mainRoot;
+}
+async function resolveCommit(git, project, branch, repositoryKey, mainRoot) {
     try {
         if (project.commit !== undefined) {
-            await git.run(["checkout", "--force", "--detach", project.commit], target);
-        }
-        const resolvedCommit = await git.run(["rev-parse", "HEAD"], target);
-        if (project.commit !== undefined && resolvedCommit !== project.commit) {
-            throw new ProjectDependencyError("project_dependency_commit_mismatch", `project ${project.id} resolved to an unexpected commit`, project.id);
+            await git.run(["fetch", "--no-tags", "origin", project.commit], mainRoot);
+            const resolved = await git.run(["rev-parse", "FETCH_HEAD"], mainRoot);
+            if (resolved !== project.commit) {
+                throw new ProjectDependencyError("project_dependency_commit_mismatch", "requested commit was not resolved", repositoryKey);
+            }
+            return resolved;
         }
-        return { resolvedCommit, created };
+        await git.run(["fetch", "--no-tags", "origin", branch], mainRoot);
+        return await git.run(["rev-parse", "origin/" + branch], mainRoot);
     }
-    catch {
-        if (project.commit !== undefined) {
-            throw new ProjectDependencyError("project_dependency_commit_mismatch", `project ${project.id} could not be checked out at the requested commit`, project.id);
-        }
-        throw new ProjectDependencyError("project_dependency_checkout_failed", "checkout commit cannot be resolved", project.id);
+    catch (error) {
+        if (error instanceof ProjectDependencyError)
+            throw error;
+        throw new ProjectDependencyError("project_dependency_checkout_failed", "cannot resolve repository commit", repositoryKey);
     }
 }
-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);
+async function ensureWorktree(git, mainRoot, repositoryKey, branch, resolvedCommit) {
+    const worktreeRoot = resolve(mainRoot, ".worktrees", worktreeDirectoryName(branch, resolvedCommit));
+    if (!isWithin(mainRoot, worktreeRoot) || await existingAncestorIsSymlink(mainRoot, worktreeRoot)) {
+        throw new ProjectDependencyError("project_dependency_checkout_conflict", "worktree path is unsafe", repositoryKey);
     }
-    const rootInfo = await lstat(resolvedRoot).catch(() => null);
-    return rootInfo?.isSymbolicLink() === true;
-};
-async function ensureRegistered(registry, project, root) {
-    let registrations;
-    try {
-        registrations = await registry.list();
+    const info = await lstat(worktreeRoot).catch(() => null);
+    if (info?.isSymbolicLink() || (info !== null && !info.isDirectory())) {
+        throw new ProjectDependencyError("project_dependency_checkout_conflict", "worktree target is not a directory", repositoryKey);
     }
-    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) {
+    if (info !== null) {
         try {
-            await registry.add(project.id, root);
+            const head = await git.run(["rev-parse", "HEAD"], worktreeRoot);
+            const dirty = await git.run(["status", "--porcelain"], worktreeRoot);
+            if (dirty.length > 0) {
+                throw new ProjectDependencyError("project_dependency_checkout_dirty", "worktree has local changes", repositoryKey);
+            }
+            if (head !== resolvedCommit) {
+                throw new ProjectDependencyError("project_dependency_checkout_conflict", "worktree commit does not match", repositoryKey);
+            }
+            return worktreeRoot;
         }
         catch (error) {
-            throw new ProjectDependencyError("project_dependency_registration_conflict", `cannot register project ${project.id}`, project.id);
+            if (error instanceof ProjectDependencyError)
+                throw error;
+            throw new ProjectDependencyError("project_dependency_checkout_conflict", "cannot inspect worktree", repositoryKey);
         }
-        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.
+    await mkdir(dirname(worktreeRoot), { recursive: true });
     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;
-        }
+        await git.run(["worktree", "add", "--detach", worktreeRoot, resolvedCommit], mainRoot);
+        return worktreeRoot;
     }
     catch {
-        throw new ProjectDependencyError("project_dependency_registration_conflict", `cannot move project ${project.id} registration to the prepared checkout`, project.id);
+        await rm(worktreeRoot, { recursive: true, force: true }).catch(() => { });
+        throw new ProjectDependencyError("project_dependency_checkout_failed", "worktree creation failed", repositoryKey);
     }
 }
-export function createProjectDependencyProvisioner(options) {
+export function createProjectDependencyProvisioner(options = {}) {
     const git = options.git ?? defaultGit;
     return {
         async prepare(input) {
@@ -206,60 +215,66 @@ export function createProjectDependencyProvisioner(options) {
             dslog("project_dependencies.manifest", "读取项目依赖清单", {
                 training_root: input.trainingRoot,
                 manifest_present: manifest !== null,
-                requested_project_ids: JSON.stringify(input.projectIds),
-                declared_project_ids: JSON.stringify(manifest?.projects.map((project) => project.id) ?? []),
+                declared_project_count: manifest?.projects.length ?? 0,
             });
-            if (input.projectIds.length === 0)
+            if (manifest === null)
                 return Object.freeze([]);
-            if (manifest === null) {
-                throw new ProjectDependencyError("project_dependency_manifest_missing", "project dependency manifest is missing from the active training package");
-            }
             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);
-                }
+            const grouped = new Map();
+            for (const project of manifest.projects) {
+                let identity;
                 try {
                     validateAbilityGitHost(project.repo);
+                    identity = normalizeRepositoryIdentity(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);
+                    throw new ProjectDependencyError("project_dependency_host_not_allowed", "repository host is not allowed");
                 }
-                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);
+                const existing = grouped.get(identity.repositoryKey);
+                if (existing === undefined)
+                    grouped.set(identity.repositoryKey, { identity, projects: [project] });
+                else
+                    existing.projects.push(project);
+            }
+            const results = [];
+            const lockRoot = input.lockRoot ?? join(dirname(resolve(input.reposRoot)), ".crew", "project-dependencies");
+            for (const { identity, projects } of grouped.values()) {
                 try {
-                    await ensureRegistered(options.registry, project, root);
+                    await withProjectDependencyLock(lockRoot, identity.repositoryKey, async () => {
+                        const mainRoot = await ensureMainClone(git, projects[0].repo, identity.repositoryKey, input.reposRoot);
+                        const seenVersions = new Set();
+                        for (const project of projects) {
+                            const branchSource = project.branch === undefined ? "remote-default" : "manifest";
+                            const branch = project.branch ?? await resolveDefaultBranch(git, project.repo, identity.repositoryKey);
+                            const resolvedCommit = await resolveCommit(git, project, branch, identity.repositoryKey, mainRoot);
+                            const versionKey = branch + "\0" + resolvedCommit;
+                            if (seenVersions.has(versionKey))
+                                continue;
+                            seenVersions.add(versionKey);
+                            const localRoot = await ensureWorktree(git, mainRoot, identity.repositoryKey, branch, resolvedCommit);
+                            results.push(Object.freeze({
+                                repositoryKey: identity.repositoryKey,
+                                displayName: identity.displayName,
+                                repo: project.repo,
+                                branch,
+                                branchSource,
+                                ...(project.commit === undefined ? {} : { requestedCommit: project.commit }),
+                                resolvedCommit,
+                                checkoutMode: "worktree",
+                                localRoot,
+                                summary: project.summary,
+                            }));
+                        }
+                    });
                 }
                 catch (error) {
-                    if (checkout.created)
-                        await rm(root, { recursive: true, force: true }).catch(() => { });
+                    if (error instanceof ProjectDependencyLockTimeoutError) {
+                        throw new ProjectDependencyError("project_dependency_checkout_conflict", "project preparation lock timed out", identity.repositoryKey);
+                    }
                     throw error;
                 }
-                results.push(Object.freeze({
-                    projectId: project.id,
-                    repo: project.repo,
-                    branch,
-                    branchSource,
-                    ...(project.commit === undefined ? {} : { requestedCommit: project.commit }),
-                    resolvedCommit: checkout.resolvedCommit,
-                    checkoutMode: "shared",
-                    localRoot: root,
-                    summary: project.summary,
-                }));
             }
             return Object.freeze(results);
         },

package/dist/project-dependency-lock.js

@@ -0,0 +1,87 @@
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const LOCK_RETRY_MS = 100;
+const LOCK_WAIT_TIMEOUT_MS = 120_000;
+const LOCK_STALE_MS = 15 * 60_000;
+const localTails = new Map();
+export class ProjectDependencyLockTimeoutError extends Error {
+    lockPath;
+    constructor(lockPath) {
+        super("project dependency preparation lock timed out");
+        this.lockPath = lockPath;
+        this.name = "ProjectDependencyLockTimeoutError";
+    }
+}
+const delay = (milliseconds) => new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+const processIsAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+};
+async function staleLock(lockPath) {
+    const owner = await readFile(join(lockPath, "owner"), "utf8").catch(() => "");
+    const pid = Number.parseInt(owner.split(" ", 1)[0] ?? "", 10);
+    if (Number.isInteger(pid) && pid > 0)
+        return !processIsAlive(pid);
+    const lockInfo = await stat(lockPath).catch(() => null);
+    return lockInfo !== null && Date.now() - lockInfo.mtimeMs > LOCK_STALE_MS;
+}
+async function acquire(lockPath) {
+    const startedAt = Date.now();
+    while (true) {
+        try {
+            await mkdir(lockPath);
+            try {
+                await writeFile(join(lockPath, "owner"), `${process.pid} ${Date.now()}\n`, "utf8");
+            }
+            catch (error) {
+                await rm(lockPath, { recursive: true, force: true }).catch(() => { });
+                throw error;
+            }
+            return async () => {
+                await rm(lockPath, { recursive: true, force: true });
+            };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            if (await staleLock(lockPath)) {
+                await rm(lockPath, { recursive: true, force: true }).catch(() => { });
+                continue;
+            }
+            if (Date.now() - startedAt >= LOCK_WAIT_TIMEOUT_MS) {
+                throw new ProjectDependencyLockTimeoutError(lockPath);
+            }
+            await delay(LOCK_RETRY_MS);
+        }
+    }
+}
+export async function withProjectDependencyLock(lockRoot, repositoryKey, operation) {
+    const root = resolve(lockRoot);
+    const lockPath = join(root, `${repositoryKey}.lock`);
+    await mkdir(root, { recursive: true });
+    const previous = localTails.get(lockPath) ?? Promise.resolve();
+    let releaseLocal;
+    const current = new Promise((resolveCurrent) => { releaseLocal = resolveCurrent; });
+    localTails.set(lockPath, current);
+    await previous;
+    let releaseFile;
+    try {
+        releaseFile = await acquire(lockPath);
+        return await operation();
+    }
+    finally {
+        try {
+            await releaseFile?.();
+        }
+        finally {
+            releaseLocal();
+            if (localTails.get(lockPath) === current)
+                localTails.delete(lockPath);
+        }
+    }
+}

package/dist/project-dependency-manifest.js

@@ -1,21 +1,16 @@
 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_MANIFEST_SOURCE_PATH = "git/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;
 export const PROJECT_COMMIT = /^[a-f0-9]{40}$/u;
 const ProjectDependencySchema = z.object({
-    id: z.string().min(1).max(64),
     repo: AbilityRepositoryUrlSchema,
     branch: z.string().min(1).max(256).optional(),
     commit: z.string().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" });
@@ -27,9 +22,4 @@ const ProjectDependencySchema = z.object({
 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" });
-    }
-});
+}).strict();

package/dist/project-registry-wiring.js

@@ -14,9 +14,6 @@ export function createProjectRegistryWiring(agentsRoot, input = {}) {
         ?? 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");
     }
@@ -24,6 +21,6 @@ export function createProjectRegistryWiring(agentsRoot, input = {}) {
         projectRegistry,
         projectWorkspaceRegistry,
         projectDependencyProvisioner: input.projectDependencies
-            ?? createProjectDependencyProvisioner({ registry: projectRegistry }),
+            ?? createProjectDependencyProvisioner(),
     });
 }

package/dist/project-skills/controller.js

@@ -183,6 +183,8 @@ export function createProjectSkillsController(deps) {
             const parsed = ProjectCommandSchema.safeParse(input);
             if (!parsed.success)
                 return { ok: false, error: "invalid_project_command" };
+            if (deps.isAdmissionClosed?.() === true)
+                return { ok: false, error: "storage_migration_quiescing" };
             try {
                 assertCurrentEpoch(epochToken);
             }

package/dist/project-skills/runtime-launch.js

@@ -57,6 +57,7 @@ export function projectSkillRuntimeLaunchFacts(runtime, root) {
 }
 /** Builds Runtime-native arrays while keeping v1 shared roots separate from v2 exact roots. */
 export async function projectSkillRuntimeDirectories(input) {
+    const trainingProjectRoots = input.trainingProjectRoots ?? [];
     const facts = projectSkillRuntimeLaunchFacts(input.runtime, input.runtimeRoot);
     const codexSkillRoots = input.runtime === "codex"
         && (input.runtimeRoot !== undefined || input.projectContext !== undefined)
@@ -79,20 +80,22 @@ export async function projectSkillRuntimeDirectories(input) {
             claudeAdditionalDirectories: await resolveOrderedUniqueClaudeDirectories([
                 ...(input.projectContext?.secondary.map((project) => project.root) ?? []),
                 facts.claudeAdditionalDirectory,
+                ...trainingProjectRoots,
                 ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
             ], input.projectContext?.primary === undefined ? [] : [input.projectContext.primary.root]),
         });
     }
     const claudeAdditionalDirectories = input.projectContext === undefined
-        ? !input.projectSkillsPresent && input.abilitySkillRoot === undefined
-            ? Object.freeze([])
-            : await resolveOrderedUniqueClaudeDirectories([
-                join(input.agentRoot, ".crew", "claude-skills"),
-                input.agentRoot,
-                ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
-            ])
+        ? await resolveOrderedUniqueClaudeDirectories([
+            ...(input.projectSkillsPresent || input.abilitySkillRoot !== undefined
+                ? [join(input.agentRoot, ".crew", "claude-skills"), input.agentRoot]
+                : []),
+            ...trainingProjectRoots,
+            ...(input.abilitySkillRoot === undefined ? [] : [input.abilitySkillRoot]),
+        ])
         : await resolveOrderedUniqueClaudeDirectories([
             ...input.projectContext.secondary.map((project) => project.root),
+            ...trainingProjectRoots,
             ...(input.projectSkillsPresent
                 ? [join(input.agentRoot, ".crew", "claude-skills")]
                 : []),