@nowcrew/daemon 0.5.33 → 0.5.35

package/README.md

@@ -166,6 +166,52 @@ Old daemons that omit `executionRuntimes` are conservatively interpreted as the
 CLIs and server-supported adapters. Unknown required protocol semantics are rejected before side effects.
 Protocol-0 `agent:start` remains only for the server-governed compatibility window.
 
+## Project Skills
+
+On macOS and Linux, an owner or admin can register multiple local project repositories from a Computer
+profile and bind selected Skills to individual Agents. The daemon keeps the only durable copy of each
+absolute path in:
+
+```text
+<CREW_AGENTS_ROOT>/.crew/projects.json
+```
+
+Each project is scanned at `<project>/.agents/skills/*/SKILL.md`. The server stores only a bounded,
+path-free inventory and logical `(projectId, skillName)` bindings. The local path crosses the server only
+while an add command is forwarded to the selected online Computer; it is not written to the workspace
+database, structured logs, inventory frames, or responses. Project Skills are disabled on Windows.
+
+One binding set is projected into both Runtime discovery layouts:
+
+```text
+<agentsRoot>/<handle>/.agents/skills/<name>                         # Codex symlink
+<agentsRoot>/<handle>/.crew/claude-skills/.claude/skills/<name>    # Claude symlink
+```
+
+The two complete directories switch under one per-Agent reconcile/launch lock. A failed switch restores
+the prior complete projection; a missing project or Skill removes only that link and does not block other
+work. These are ordinary writable symlinks, not snapshots or a sandbox: an Agent running as the daemon
+user can modify the source Skill through them. That write-through risk is intentionally accepted.
+
+Codex protocol-v1 task directories are opaque
+`<agentsRoot>/<handle>/tasks/<safe-prefix>-<sha256>` paths. The daemon writes `.nowwork-root` at the Agent
+root and adds it to Codex `project_root_markers`, so upward discovery reaches `.agents/skills` without
+changing the task cwd. Claude receives
+`--add-dir <agentsRoot>/<handle>/.crew/claude-skills`; Claude treats those Skills as `projectSettings`,
+so a machine policy that disables project settings also disables this source even when the projection is
+healthy.
+
+Existing user-level discovery is unchanged. Claude may still load `~/.claude/skills`; Codex may still
+load `$CODEX_HOME/skills`. The DeepSeek Codex variant uses its Agent-private `.codex-deepseek` home.
+Project bindings do not hide or rewrite any of those sources.
+
+Binding changes reconcile immediately when the Computer is online. On reconnect the server sends the
+complete binding set for every Agent assigned to that Computer, including empty sets that clear stale
+links left by offline unbinds. Every non-empty execution snapshot is also reconciled immediately before
+Runtime launch, which recovers from a missed notification or daemon restart. Skill file content changes
+are visible through the symlink immediately; adding, deleting, renaming, or changing frontmatter requires
+a rescan. Web descriptions remain at the last inventory value until that rescan.
+
 ## Reliability
 
 Protocol-v1 lifecycle is `accepted → started → completed`, followed by a server

package/dist/atomic-private-write.js

@@ -0,0 +1,18 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export async function atomicPrivateWrite(path, content, beforeCommit) {
+    const directory = dirname(path);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await beforeCommit?.(temporary);
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/dist/computer-profile.js

@@ -1,13 +1,13 @@
-import { access, chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, readFile, readdir, rm, stat } from "node:fs/promises";
 import { constants } from "node:fs";
 import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, posix, resolve, win32 } from "node:path";
-import { randomUUID } from "node:crypto";
+import { posix, resolve, win32 } from "node:path";
 import { spawn } from "node:child_process";
 import { z } from "zod";
 import { acquireProfileSaveLock, } from "./computer-profile-lock.js";
 import { formatDaemonText } from "./i18n.js";
+import { atomicPrivateWrite } from "./atomic-private-write.js";
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
 const ServerUrlSchema = z.string().url().max(2048).refine((value) => {
     const url = new URL(value);
@@ -130,20 +130,6 @@ export function validateProfileName(name) {
 export function profilePath(name, home = daemonHome()) {
     return resolve(home, "profiles", `${validateProfileName(name)}.json`);
 }
-async function atomicPrivateWrite(path, content, beforeCommit) {
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    await chmod(dirname(path), 0o700);
-    const temporary = `${path}.${randomUUID()}.tmp`;
-    try {
-        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
-        await beforeCommit?.(temporary);
-        await rename(temporary, path);
-        await chmod(path, 0o600);
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-}
 const DPAPI_PROTECT = "$p=[Console]::In.ReadToEnd();$b=[Text.Encoding]::UTF8.GetBytes($p);$e=[Security.Cryptography.ProtectedData]::Protect($b,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser);[Convert]::ToBase64String($e)";
 const DPAPI_UNPROTECT = "$p=[Console]::In.ReadToEnd();$b=[Convert]::FromBase64String($p);$d=[Security.Cryptography.ProtectedData]::Unprotect($b,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser);[Console]::Out.Write([Text.Encoding]::UTF8.GetString($d))";
 async function powershellStdin(script, input) {

package/dist/execution-protocol.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { MAX_AGENT_PROJECT_SKILL_BINDINGS } from "./project-skills/types.js";
 const ExecutionIdSchema = z.string().uuid();
 const ProtocolVersionSchema = z.literal(1);
 const TimestampSchema = z.string().datetime({ offset: true });
@@ -10,13 +11,17 @@ const ExitCodeSchema = z.number().int().min(MIN_SIGNED_32_INTEGER).max(MAX_PG_IN
 const RuntimeSchema = z.enum(["claude", "codex", "kimi"]);
 const UnsafePathCharacterSchema = /[\p{Cc}<>:"/\\|?*]/u;
 const WindowsReservedNameSchema = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i;
-const AgentHandleSchema = z.string().min(1).max(64).refine((handle) => handle !== "."
+export const AgentHandleSchema = z.string().min(1).max(64).refine((handle) => handle !== "."
     && handle !== ".."
     && !UnsafePathCharacterSchema.test(handle)
     && !WindowsReservedNameSchema.test(handle)
     && !handle.endsWith(".")
     && !handle.endsWith(" ")
     && Buffer.byteLength(handle, "utf8") <= 255, "agent handle must be a cross-platform safe filesystem component");
+const ProjectSkillRefSchema = z.object({
+    projectId: z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9._-]*$/u),
+    skillName: z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9._:-]*$/u),
+}).strict();
 export const ReasoningSchema = z.enum([
     "default",
     "none",
@@ -99,6 +104,7 @@ export const ExecutionStartSchema = z.object({
         id: z.string().min(1),
         handle: AgentHandleSchema,
         memoryEnabled: z.boolean().optional(),
+        projectSkills: z.array(ProjectSkillRefSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS).optional(),
     }).strict(),
     workspace: z.object({
         taskKey: z.string().min(1).max(200),

package/dist/execution-runner.js

@@ -505,6 +505,7 @@ export async function runExecution(config, input, dependencies) {
             ...(dependencies.startupTimeoutMs === undefined
                 ? {}
                 : { startupTimeoutMs: dependencies.startupTimeoutMs }),
+            ...(dependencies.projectSkills === undefined ? {} : { projectSkills: dependencies.projectSkills }),
             launchRuntime: async (request) => {
                 if (launchClosed || dependencies.cancellation?.isRequested())
                     throw new ExecutionCancelledError();
@@ -572,6 +573,7 @@ export async function runExecution(config, input, dependencies) {
             ...(spec.workspace.resumeKey === undefined ? {} : { resumeKey: spec.workspace.resumeKey }),
             ...(spec.context.wakeMessageId === undefined ? {} : { wakeMessageId: spec.context.wakeMessageId }),
             ...(spec.context.attachments === undefined ? {} : { attachments: spec.context.attachments }),
+            ...(spec.agent.projectSkills === undefined ? {} : { projectSkills: spec.agent.projectSkills }),
             systemPrompt: boundedSystemPrompt,
             wakePrompt: spec.instructions.wakePrompt,
             runtime: {

package/dist/local-executor.js

@@ -116,6 +116,9 @@ async function launchLegacyRuntime(request) {
             ...common,
             systemPromptPath: request.systemPromptPath,
             wakePrompt: request.wakePrompt,
+            ...(request.agentRoot === undefined ? {} : {
+                projectSkillsDirectory: join(request.agentRoot, ".crew", "claude-skills"),
+            }),
             ...(request.sessionId === undefined ? {} : {
                 sessionId: request.sessionId,
                 resume: request.resume,
@@ -318,10 +321,11 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         const runtimeLaunchAt = Date.now();
-        const child = await launchRuntime({
+        const launchRequest = {
             runtime: runtime.name,
             bin: runtime.name,
             cwd: workspace.runDir,
+            ...(input.projectSkills === undefined ? {} : { agentRoot: workspace.dir }),
             systemPromptPath: workspace.systemPromptPath,
             systemPrompt,
             wakePrompt,
@@ -334,7 +338,10 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ...(attachmentPlan.nativeImagePaths.length > 0
                 ? { imagePaths: attachmentPlan.nativeImagePaths }
                 : {}),
-        });
+        };
+        const child = input.projectSkills !== undefined && dependencies.projectSkills !== undefined
+            ? await dependencies.projectSkills.prepareAndLaunch(input.launch.agentsRoot, input.handle, input.projectSkills, () => launchRuntime(launchRequest))
+            : await launchRuntime(launchRequest);
         if (child.cancel !== undefined) {
             dependencies.cancellation?.register(child.cancel);
         }

package/dist/machine-info.js

@@ -27,7 +27,11 @@ export const DAEMON_CAPABILITIES = [
     "execution_answer_stream_v1",
     "execution_machine_queue_v1",
     "execution_agent_memory_policy_v1",
+    "project_skills_v1",
 ];
+export const daemonCapabilities = (runtimePlatform = process.platform) => runtimePlatform === "darwin" || runtimePlatform === "linux"
+    ? DAEMON_CAPABILITIES
+    : DAEMON_CAPABILITIES.filter((capability) => capability !== "project_skills_v1");
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
 const RUNTIME_BINS = [
@@ -117,7 +121,7 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         daemonVersion: daemonVersion(),
         runtimes,
         executionRuntimes,
-        capabilities: [...DAEMON_CAPABILITIES, ...additionalCapabilities],
+        capabilities: [...daemonCapabilities(runtimePlatform), ...additionalCapabilities],
         ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
             executionLimits: Object.freeze({

package/dist/project-skills/agent-projection-coordinator.js

@@ -0,0 +1,10 @@
+import { createKeyedPromiseTail } from "../promise-tail.js";
+export function createAgentProjectionCoordinator() {
+    const tails = createKeyedPromiseTail();
+    return {
+        runExclusive(agentsRoot, handle, operation) {
+            const key = JSON.stringify([agentsRoot, handle]);
+            return tails.enqueue(key, operation);
+        },
+    };
+}

package/dist/project-skills/controller.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import { scanProjects } from "./scanner.js";
+import { ProjectRegistryError } from "./registry.js";
+import { isProjectId, isProjectSkillName, MAX_AGENT_PROJECT_SKILL_BINDINGS, } from "./types.js";
+import { AgentHandleSchema } from "../execution-protocol.js";
+import { createPromiseTail } from "../promise-tail.js";
+const ProjectIdSchema = z.string().refine(isProjectId);
+const ProjectCommandSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("project:add"),
+        reqId: z.string().min(1).max(128),
+        projectId: ProjectIdSchema,
+        root: z.string().min(1).max(4_096),
+    }).strict(),
+    z.object({
+        type: z.literal("project:remove"),
+        reqId: z.string().min(1).max(128),
+        projectId: ProjectIdSchema,
+    }).strict(),
+    z.object({
+        type: z.literal("project:rescan"),
+        reqId: z.string().min(1).max(128),
+        projectId: ProjectIdSchema,
+    }).strict(),
+    z.object({
+        type: z.literal("agent:skills:sync"),
+        reqId: z.string().min(1).max(128),
+        handle: AgentHandleSchema,
+        bindings: z.array(z.object({
+            projectId: ProjectIdSchema,
+            skillName: z.string().refine(isProjectSkillName),
+        }).strict()).max(MAX_AGENT_PROJECT_SKILL_BINDINGS),
+    }).strict(),
+]);
+export function createProjectSkillsController(deps) {
+    let scanned = Object.freeze([]);
+    const operationTail = createPromiseTail();
+    let initialization = null;
+    let initializationState = "idle";
+    const refresh = async () => {
+        scanned = await scanProjects(await deps.registry.list());
+    };
+    const publishCurrent = async () => {
+        await deps.publish(Object.freeze({
+            type: "machine:projects",
+            projects: Object.freeze(scanned.map((project) => project.inventory)),
+        }));
+    };
+    const enqueue = (operation) => operationTail.enqueue(operation);
+    return {
+        initialize() {
+            if (initialization !== null)
+                return initialization;
+            initializationState = "initializing";
+            initialization = enqueue(refresh).then(() => { initializationState = "ready"; }, (error) => {
+                initializationState = "failed";
+                throw error;
+            });
+            return initialization;
+        },
+        publishCurrent: () => enqueue(publishCurrent),
+        scannedProjects: () => scanned,
+        handle(input) {
+            return enqueue(async () => {
+                const parsed = ProjectCommandSchema.safeParse(input);
+                if (!parsed.success)
+                    return { ok: false, error: "invalid_project_command" };
+                if (initializationState !== "ready") {
+                    return { ok: false, error: "project_skills_unavailable" };
+                }
+                const command = parsed.data;
+                try {
+                    if (command.type === "agent:skills:sync") {
+                        if (deps.reconcile === undefined)
+                            return { ok: false, error: "skill_projection_failed" };
+                        return {
+                            ok: true,
+                            data: { bindings: await deps.reconcile(command.handle, command.bindings) },
+                        };
+                    }
+                    if (command.type === "project:add") {
+                        await deps.registry.add(command.projectId, command.root);
+                    }
+                    else if (command.type === "project:remove") {
+                        await deps.registry.remove(command.projectId);
+                    }
+                    else {
+                        const projects = await deps.registry.list();
+                        if (!projects.some((project) => project.projectId === command.projectId)) {
+                            return { ok: false, error: "project_not_found" };
+                        }
+                    }
+                    await refresh();
+                    await publishCurrent();
+                    return { ok: true, data: { projectId: command.projectId } };
+                }
+                catch (error) {
+                    return {
+                        ok: false,
+                        error: error instanceof ProjectRegistryError
+                            ? error.code
+                            : error.code === "skill_name_conflict"
+                                ? "skill_name_conflict"
+                                : error.code === "skill_projection_failed"
+                                    ? "skill_projection_failed"
+                                    : "project_operation_failed",
+                    };
+                }
+            });
+        },
+    };
+}

package/dist/project-skills/reconciler.js

@@ -0,0 +1,116 @@
+import { lstat, mkdir, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+export class ProjectProjectionError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ProjectProjectionError";
+    }
+}
+const exists = async (path) => lstat(path).then(() => true, () => false);
+async function switchProjectionSet(targets) {
+    const moved = [];
+    try {
+        for (const target of targets) {
+            const hadPrevious = await exists(target.target);
+            if (hadPrevious)
+                await rename(target.target, target.backup);
+            const state = { target, hadPrevious, activated: false };
+            moved.push(state);
+            await rename(target.staging, target.target);
+            state.activated = true;
+        }
+    }
+    catch (error) {
+        for (const state of [...moved].reverse()) {
+            if (state.activated)
+                await rm(state.target.target, { recursive: true, force: true }).catch(() => { });
+            if (state.hadPrevious)
+                await rename(state.target.backup, state.target.target).catch(() => { });
+        }
+        throw error;
+    }
+    await Promise.all(targets.map((target) => rm(target.backup, { recursive: true, force: true })));
+}
+export function createProjectSkillsReconciler(deps) {
+    const platform = deps.platform ?? process.platform;
+    const reconcileUnlocked = async (handle, bindings) => {
+        if (platform !== "darwin" && platform !== "linux") {
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        const projects = deps.scannedProjects();
+        const uniqueBindings = [...new Map(bindings.map((binding) => [
+                `${binding.projectId}\0${binding.skillName}`,
+                binding,
+            ])).values()].sort((left, right) => left.projectId.localeCompare(right.projectId) || left.skillName.localeCompare(right.skillName));
+        const names = new Map();
+        for (const binding of uniqueBindings) {
+            const owner = names.get(binding.skillName);
+            if (owner !== undefined && owner !== binding.projectId) {
+                throw new ProjectProjectionError("skill_name_conflict");
+            }
+            names.set(binding.skillName, binding.projectId);
+        }
+        const linked = [];
+        const resolutions = [];
+        for (const binding of uniqueBindings) {
+            const project = projects.find((candidate) => candidate.inventory.projectId === binding.projectId
+                && candidate.inventory.status === "available");
+            const skill = project?.resolved.find((candidate) => candidate.name === binding.skillName);
+            const available = skill !== undefined && (await stat(skill.sourcePath).catch(() => null))?.isDirectory() === true;
+            resolutions.push(Object.freeze({ ...binding, status: available ? "linked" : "unavailable" }));
+            if (available && skill !== undefined)
+                linked.push({ binding, skill });
+        }
+        const agentRoot = join(deps.agentsRoot, handle);
+        const id = randomUUID();
+        const targets = [
+            {
+                runtime: "codex",
+                target: join(agentRoot, ".agents", "skills"),
+                staging: join(agentRoot, ".agents", `.skills-next-${id}`),
+                backup: join(agentRoot, ".agents", `.skills-previous-${id}`),
+            },
+            {
+                runtime: "claude",
+                target: join(agentRoot, ".crew", "claude-skills", ".claude", "skills"),
+                staging: join(agentRoot, ".crew", "claude-skills", ".claude", `.skills-next-${id}`),
+                backup: join(agentRoot, ".crew", "claude-skills", ".claude", `.skills-previous-${id}`),
+            },
+        ];
+        try {
+            for (const target of targets) {
+                await mkdir(dirname(target.target), { recursive: true });
+                await mkdir(target.staging, { mode: 0o700 });
+                for (const item of linked) {
+                    await symlink(item.skill.sourcePath, join(target.staging, item.binding.skillName), "dir");
+                }
+            }
+            for (const target of targets)
+                await deps.beforeSwitch?.(target.runtime);
+            await switchProjectionSet(targets);
+            await writeFile(join(agentRoot, ".nowwork-root"), "", { encoding: "utf8", mode: 0o600 });
+            return Object.freeze(resolutions);
+        }
+        catch {
+            await Promise.all(targets.map((target) => rm(target.staging, { recursive: true, force: true })));
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+    };
+    return {
+        reconcile(handle, bindings) {
+            return deps.coordinator.runExclusive(deps.agentsRoot, handle, () => reconcileUnlocked(handle, bindings));
+        },
+        prepareAndLaunch(agentsRoot, handle, bindings, launch) {
+            if (agentsRoot !== deps.agentsRoot) {
+                return Promise.reject(new ProjectProjectionError("skill_projection_failed"));
+            }
+            return deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => {
+                await reconcileUnlocked(handle, bindings);
+                return launch();
+            });
+        },
+    };
+}

package/dist/project-skills/registry.js

@@ -0,0 +1,101 @@
+import { readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+import { isProjectId, MAX_MACHINE_PROJECTS } from "./types.js";
+import { createPromiseTail } from "../promise-tail.js";
+import { atomicPrivateWrite } from "../atomic-private-write.js";
+const RegistryFileSchema = z.object({
+    version: z.literal(1),
+    projects: z.record(z.object({ root: z.string().min(1).max(4_096) }).strict())
+        .refine((projects) => Object.keys(projects).length <= MAX_MACHINE_PROJECTS),
+}).strict();
+export class ProjectRegistryError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "ProjectRegistryError";
+    }
+}
+const immutableList = (projects) => Object.freeze(Object.entries(projects)
+    .map(([projectId, project]) => Object.freeze({ projectId, root: project.root }))
+    .sort((left, right) => left.projectId.localeCompare(right.projectId)));
+export function createProjectRegistry(agentsRoot) {
+    const path = join(agentsRoot, ".crew", "projects.json");
+    const writeTail = createPromiseTail();
+    const load = async () => {
+        let raw;
+        try {
+            raw = await readFile(path, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return Object.freeze({});
+            throw new ProjectRegistryError("project_registry_corrupt");
+        }
+        try {
+            const parsed = RegistryFileSchema.parse(JSON.parse(raw));
+            for (const [projectId, project] of Object.entries(parsed.projects)) {
+                if (!isProjectId(projectId) || !isAbsolute(project.root)) {
+                    throw new ProjectRegistryError("project_registry_corrupt");
+                }
+            }
+            return Object.freeze(Object.fromEntries(Object.entries(parsed.projects).map(([projectId, project]) => [
+                projectId,
+                Object.freeze({ root: resolve(project.root) }),
+            ])));
+        }
+        catch (error) {
+            if (error instanceof ProjectRegistryError)
+                throw error;
+            throw new ProjectRegistryError("project_registry_corrupt");
+        }
+    };
+    const save = async (projects) => {
+        await atomicPrivateWrite(path, `${JSON.stringify({ version: 1, projects }, null, 2)}\n`);
+    };
+    const enqueue = (operation) => writeTail.enqueue(operation);
+    return {
+        path,
+        async list() {
+            await writeTail.wait();
+            return immutableList(await load());
+        },
+        add(projectId, root) {
+            return enqueue(async () => {
+                if (!isProjectId(projectId))
+                    throw new ProjectRegistryError("project_id_invalid");
+                if (!isAbsolute(root))
+                    throw new ProjectRegistryError("project_path_invalid");
+                const normalizedRoot = resolve(root);
+                const rootStat = await stat(normalizedRoot).catch(() => null);
+                if (!rootStat?.isDirectory())
+                    throw new ProjectRegistryError("project_path_invalid");
+                const projects = await load();
+                const existing = projects[projectId];
+                if (existing?.root === normalizedRoot)
+                    return Object.freeze({ projectId, root: normalizedRoot });
+                if (existing !== undefined)
+                    throw new ProjectRegistryError("project_id_conflict");
+                if (Object.keys(projects).length >= MAX_MACHINE_PROJECTS) {
+                    throw new ProjectRegistryError("project_limit_exceeded");
+                }
+                const next = Object.freeze({ ...projects, [projectId]: Object.freeze({ root: normalizedRoot }) });
+                await save(next);
+                return Object.freeze({ projectId, root: normalizedRoot });
+            });
+        },
+        remove(projectId) {
+            return enqueue(async () => {
+                if (!isProjectId(projectId))
+                    throw new ProjectRegistryError("project_id_invalid");
+                const projects = await load();
+                if (projects[projectId] === undefined)
+                    return false;
+                const next = Object.fromEntries(Object.entries(projects).filter(([candidate]) => candidate !== projectId));
+                await save(Object.freeze(next));
+                return true;
+            });
+        },
+    };
+}

package/dist/project-skills/scanner.js

@@ -0,0 +1,103 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { isProjectSkillName, MAX_MACHINE_PROJECT_SKILLS, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILLS_PER_PROJECT, } from "./types.js";
+import { parseSkillFrontmatter } from "../skill-frontmatter.js";
+const unavailable = (projectId, scannedAt, errorCode) => Object.freeze({
+    inventory: Object.freeze({
+        projectId,
+        status: "unavailable",
+        skills: Object.freeze([]),
+        invalidSkillCount: 0,
+        errorCode,
+        scannedAt,
+    }),
+    resolved: Object.freeze([]),
+});
+export async function scanProject(project, now = () => new Date()) {
+    const scannedAt = now().toISOString();
+    const projectStat = await stat(project.root).catch(() => null);
+    if (!projectStat?.isDirectory())
+        return unavailable(project.projectId, scannedAt, "project_path_unavailable");
+    const skillsRoot = join(project.root, ".agents", "skills");
+    let entries;
+    try {
+        entries = await readdir(skillsRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return Object.freeze({
+                inventory: Object.freeze({
+                    projectId: project.projectId,
+                    status: "available",
+                    skills: Object.freeze([]),
+                    invalidSkillCount: 0,
+                    errorCode: null,
+                    scannedAt,
+                }),
+                resolved: Object.freeze([]),
+            });
+        }
+        return unavailable(project.projectId, scannedAt, "project_skills_unreadable");
+    }
+    let invalidSkillCount = 0;
+    const candidates = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (entry.name.startsWith(".") || !entry.isDirectory())
+            continue;
+        const sourcePath = join(skillsRoot, entry.name);
+        const markdown = await readFile(join(sourcePath, "SKILL.md"), "utf8").catch(() => null);
+        if (markdown === null) {
+            invalidSkillCount += 1;
+            continue;
+        }
+        const frontmatter = parseSkillFrontmatter(markdown);
+        const name = frontmatter?.name ?? entry.name;
+        const description = frontmatter?.description ?? "";
+        if (!isProjectSkillName(name) || description.length > MAX_PROJECT_SKILL_DESCRIPTION_LENGTH) {
+            invalidSkillCount += 1;
+            continue;
+        }
+        candidates.push(Object.freeze({ name, description, sourcePath }));
+    }
+    const counts = new Map();
+    for (const candidate of candidates)
+        counts.set(candidate.name, (counts.get(candidate.name) ?? 0) + 1);
+    const resolved = candidates.filter((candidate) => {
+        if (counts.get(candidate.name) === 1)
+            return true;
+        invalidSkillCount += 1;
+        return false;
+    }).sort((left, right) => left.name.localeCompare(right.name));
+    const skills = resolved.map(({ name, description }) => Object.freeze({ name, description }));
+    if (skills.length > MAX_PROJECT_SKILLS_PER_PROJECT) {
+        return unavailable(project.projectId, scannedAt, "project_skill_limit_exceeded");
+    }
+    return Object.freeze({
+        inventory: Object.freeze({
+            projectId: project.projectId,
+            status: "available",
+            skills: Object.freeze(skills),
+            invalidSkillCount,
+            errorCode: null,
+            scannedAt,
+        }),
+        resolved: Object.freeze(resolved),
+    });
+}
+export function boundScannedProjects(projects) {
+    let skillCount = 0;
+    return Object.freeze(projects.map((project) => {
+        if (project.inventory.status !== "available")
+            return project;
+        const nextCount = skillCount + project.inventory.skills.length;
+        if (nextCount <= MAX_MACHINE_PROJECT_SKILLS) {
+            skillCount = nextCount;
+            return project;
+        }
+        return unavailable(project.inventory.projectId, project.inventory.scannedAt, "machine_project_skill_limit_exceeded");
+    }));
+}
+export async function scanProjects(projects, now = () => new Date()) {
+    const sorted = [...projects].sort((left, right) => left.projectId.localeCompare(right.projectId));
+    return boundScannedProjects(await Promise.all(sorted.map((project) => scanProject(project, now))));
+}

package/dist/project-skills/types.js

@@ -0,0 +1,12 @@
+export const PROJECT_SKILLS_CAPABILITY = "project_skills_v1";
+export const MAX_PROJECT_ID_LENGTH = 64;
+export const MAX_PROJECT_SKILL_NAME_LENGTH = 128;
+export const MAX_PROJECT_SKILL_DESCRIPTION_LENGTH = 1_000;
+export const MAX_PROJECT_SKILLS_PER_PROJECT = 1_000;
+export const MAX_MACHINE_PROJECTS = 100;
+export const MAX_MACHINE_PROJECT_SKILLS = 1_000;
+export const MAX_AGENT_PROJECT_SKILL_BINDINGS = 500;
+const PROJECT_ID = /^[a-z0-9][a-z0-9._-]*$/u;
+const SKILL_NAME = /^[a-z0-9][a-z0-9._:-]*$/u;
+export const isProjectId = (value) => value.length > 0 && value.length <= MAX_PROJECT_ID_LENGTH && PROJECT_ID.test(value);
+export const isProjectSkillName = (value) => value.length > 0 && value.length <= MAX_PROJECT_SKILL_NAME_LENGTH && SKILL_NAME.test(value);

package/dist/promise-tail.js

@@ -0,0 +1,25 @@
+export function createKeyedPromiseTail() {
+    const tails = new Map();
+    return {
+        enqueue(key, operation) {
+            const previous = tails.get(key) ?? Promise.resolve();
+            const current = previous.catch(() => { }).then(operation);
+            const tail = current.then(() => undefined);
+            tails.set(key, tail);
+            void tail.finally(() => {
+                if (tails.get(key) === tail)
+                    tails.delete(key);
+            }).catch(() => { });
+            return current;
+        },
+        pending: (key) => tails.get(key),
+    };
+}
+export function createPromiseTail() {
+    const queue = createKeyedPromiseTail();
+    const key = "singleton";
+    return {
+        enqueue: (operation) => queue.enqueue(key, operation),
+        wait: () => queue.pending(key)?.catch(() => { }) ?? Promise.resolve(),
+    };
+}

package/dist/runner.js

@@ -154,6 +154,9 @@ export async function runAgent(config, input, onActivity = defaultPrint, onConso
             exitCode: local.exitCode,
             finalText: local.finalText,
             errorMessage: local.errorMessage,
+            ...(input.scheduled.serverOwnsFailureNotice?.() === true
+                ? { suppressFailureNotice: true }
+                : {}),
             send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
                 content,
                 force: true,
@@ -194,6 +197,7 @@ export async function reportScheduledStartFailure(config, input) {
         exitCode: -1,
         finalText: null,
         errorMessage: input.errorMessage,
+        ...(input.serverOwnsFailureNotice?.() === true ? { suppressFailureNotice: true } : {}),
         send: (content) => sendAgentMessage(config.serverUrl, credential.token, input.channelId, {
             content,
             force: true,

package/dist/runtimes/claude.js

@@ -28,6 +28,8 @@ export function buildClaudeArgs(input) {
     if (input.sessionId) {
         args.push(input.resume ? "--resume" : "--session-id", input.sessionId);
     }
+    if (input.projectSkillsDirectory)
+        args.push("--add-dir", input.projectSkillsDirectory);
     if (input.effectivePermission === undefined) {
         if (input.dangerous)
             args.push("--dangerously-skip-permissions");

package/dist/runtimes/codex-app-server-runner.js

@@ -14,6 +14,7 @@ const RunnerInputSchema = z.object({
     reasoning: z.string().min(1).optional(),
     sessionId: z.string().min(1).optional(),
     imagePaths: z.array(z.string().min(1)).optional(),
+    projectRootMarkers: z.array(z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/u)).max(16).optional(),
     resume: z.boolean(),
 }).strict();
 const RPC_TIMEOUT_MS = 30_000;
@@ -31,6 +32,14 @@ const MAX_TRANSIENT_TURN_RETRIES = 2;
 const TRANSIENT_TURN_RETRY_DELAY_MS = 15_000;
 const TRANSIENT_TURN_RETRY_BACKOFF_FACTOR = 3;
 const PROCESS_TREE_STOP_TIMEOUT_MS = 1_000;
+export function codexAppServerArgs(projectRootMarkers) {
+    return [
+        ...(projectRootMarkers === undefined
+            ? []
+            : ["-c", `project_root_markers=${JSON.stringify(projectRootMarkers)}`]),
+        "app-server", "--listen", "stdio://",
+    ];
+}
 const TRANSIENT_TURN_ERROR_PATTERNS = [
     /at capacity/i,
     /overloaded/i,
@@ -345,7 +354,7 @@ async function stopChildTree(child) {
 }
 async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs) {
     const attemptStartedAt = Date.now();
-    const child = spawn(bin, ["app-server", "--listen", "stdio://"], {
+    const child = spawn(bin, codexAppServerArgs(input.projectRootMarkers), {
         cwd: process.cwd(),
         env: process.env,
         stdio: ["pipe", "pipe", "pipe"],

package/dist/scheduled-report.js

@@ -18,6 +18,9 @@ export async function deliverScheduledReport(input) {
     let source = "none";
     let content = null;
     if (input.exitCode !== 0) {
+        if (input.suppressFailureNotice === true) {
+            return { required: false, attempted: false, delivered: false, source: "none" };
+        }
         source = "failure_notice";
         const detail = input.errorMessage?.trim().slice(0, 500);
         content = `Scheduled job "${title}" failed${detail ? `: ${detail}` : ` (exit ${input.exitCode})`}.`;

package/dist/serve.js

@@ -8,7 +8,7 @@ import { randomUUID } from "node:crypto";
 import { initSlog, dslog, setSlogDefaults, drainSpool, flushSlog } from "./slog.js";
 import { mergeRunAgentResults, reportScheduledStartFailure, runAgent } from "./runner.js";
 import { buildOriginDecisionRetryPrompt, buildScheduledPrompt } from "./prompt.js";
-import { collectMachineHello, DAEMON_CAPABILITIES, EXECUTION_PROTOCOL, } from "./machine-info.js";
+import { collectMachineHello, daemonCapabilities, EXECUTION_PROTOCOL, } from "./machine-info.js";
 import { listWorkspace, readWorkspaceFile } from "./workspace-fs.js";
 import { listSkills } from "./skills.js";
 import { inspectRaftWorkspace, importRaftWorkspace } from "./workspace-import.js";
@@ -35,26 +35,35 @@ import { detectDaemonUpdateEligibility, } from "./daemon-update-eligibility.js";
 import { createDaemonUpdateController } from "./daemon-update-controller.js";
 import { installExactDaemonUpdate } from "./daemon-updater.js";
 import { scheduleServiceRestart } from "./computer-service.js";
+import { createProjectRegistry } from "./project-skills/registry.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";
+import { createProjectSkillsReconciler, ProjectProjectionError, } from "./project-skills/reconciler.js";
 // normalize.ts 的活动种类 → activity 枚举
 const ACTIVITY_MAP = {
     init: "working", text: "thinking", reading: "reading", sending: "sending",
     checking: "checking", claiming: "claiming", crew: "working", tool: "working",
     tool_result: "working", done: "done", error: "error",
 };
-export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe) {
+export function buildControlPlaneUrl(serverUrl, machineToken, runtimePlatform = process.platform, jobObjectProbe, projectSkillsAvailable = true) {
     const query = new URLSearchParams({ key: machineToken });
     if (executionBackendCapability(runtimePlatform, jobObjectProbe).supported) {
         query.set("execution_min", String(EXECUTION_PROTOCOL.min));
         query.set("execution_max", String(EXECUTION_PROTOCOL.max));
     }
-    for (const capability of DAEMON_CAPABILITIES)
-        query.append("capability", capability);
+    for (const capability of daemonCapabilities(runtimePlatform)) {
+        if (capability !== PROJECT_SKILLS_CAPABILITY || projectSkillsAvailable) {
+            query.append("capability", capability);
+        }
+    }
     return `${serverUrl.replace(/^http/, "ws").replace(/\/+$/, "")}/daemon/connect?${query.toString()}`;
 }
 export function serve(config, opts = {}) {
-    const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken);
     let stopped = false;
     let ws = null;
+    // 当前连接的 server 能力(ready 帧下发;重连后由新 ready 帧刷新)。
+    let serverCapabilities = new Set();
     let backoff = 1000;
     const maxBackoff = opts.maxBackoffMs ?? 30_000;
     const testShutdown = readTestShutdownConfiguration(process.env);
@@ -97,6 +106,45 @@ export function serve(config, opts = {}) {
             catch { /* reconnect/timeout reconciliation handles a lost status frame */ }
         },
     });
+    const projectionCoordinator = createAgentProjectionCoordinator();
+    let projectSkillsController;
+    const projectSkillsReconciler = opts.projectSkills?.reconciler ?? createProjectSkillsReconciler({
+        agentsRoot: config.agentsRoot,
+        coordinator: projectionCoordinator,
+        scannedProjects: () => projectSkillsController.scannedProjects(),
+    });
+    projectSkillsController = opts.projectSkills?.controller ?? createProjectSkillsController({
+        registry: createProjectRegistry(config.agentsRoot),
+        publish: (frame) => {
+            if (!serverCapabilities.has(PROJECT_SKILLS_CAPABILITY))
+                return;
+            try {
+                if (ws?.readyState === WebSocket.OPEN)
+                    ws.send(JSON.stringify(frame));
+            }
+            catch { /* 下一次 ready 或项目操作会重新发送完整快照 */ }
+        },
+        reconcile: (handle, bindings) => projectSkillsReconciler.reconcile(handle, bindings),
+    });
+    const projectSkillsInitialized = projectSkillsController.initialize().then(() => true, (error) => {
+        dslog("project_skills.registry_failed", "本机项目注册表读取失败", {
+            level: "ERROR", error_code: error.code ?? "project_registry_corrupt",
+        });
+        return false;
+    });
+    let projectSkillsAvailable = false;
+    const initializedProjectSkillsReconciler = {
+        reconcile(handle, bindings) {
+            return projectSkillsAvailable
+                ? projectSkillsReconciler.reconcile(handle, bindings)
+                : Promise.reject(new ProjectProjectionError("skill_projection_failed"));
+        },
+        prepareAndLaunch(agentsRoot, handle, bindings, launch) {
+            return projectSkillsAvailable
+                ? projectSkillsReconciler.prepareAndLaunch(agentsRoot, handle, bindings, launch)
+                : Promise.reject(new ProjectProjectionError("skill_projection_failed"));
+        },
+    };
     const safeExecutionSend = (frame) => {
         try {
             if (ws?.readyState !== WebSocket.OPEN)
@@ -205,6 +253,7 @@ export function serve(config, opts = {}) {
     function connect() {
         if (stopped)
             return;
+        const wsUrl = buildControlPlaneUrl(config.serverUrl, config.machineToken, process.platform, undefined, projectSkillsAvailable);
         ws = createWebSocket(wsUrl);
         ws.on("open", () => {
             const openedSocket = ws;
@@ -234,9 +283,15 @@ export function serve(config, opts = {}) {
             void helloPromise
                 .then((hello) => {
                 detectedExecutionRuntimes = hello.executionRuntimes;
+                const effectiveHello = projectSkillsAvailable
+                    ? hello
+                    : {
+                        ...hello,
+                        capabilities: hello.capabilities.filter((capability) => capability !== PROJECT_SKILLS_CAPABILITY),
+                    };
                 try {
-                    ws?.send(JSON.stringify(hello));
-                    log(`📤 已上报机器信息: ${hello.hostname} · ${hello.os} · installed=[${hello.runtimes.join(",")}] · executable=[${hello.executionRuntimes.join(",")}] · agents=[${hello.agentHandles.join(",")}]`);
+                    ws?.send(JSON.stringify(effectiveHello));
+                    log(`📤 已上报机器信息: ${effectiveHello.hostname} · ${effectiveHello.os} · installed=[${effectiveHello.runtimes.join(",")}] · executable=[${effectiveHello.executionRuntimes.join(",")}] · agents=[${effectiveHello.agentHandles.join(",")}]`);
                 }
                 catch { /* 非 OPEN,忽略 */ }
             })
@@ -437,6 +492,7 @@ export function serve(config, opts = {}) {
                     }
                     const execution = executeProtocol(config, spec, {
                         ...opts.execution?.dependencies,
+                        projectSkills: opts.execution?.dependencies?.projectSkills ?? initializedProjectSkillsReconciler,
                         ...(agentMemory === undefined ? {} : { agentMemory }),
                         journal: executionJournal,
                         facts: {
@@ -506,6 +562,14 @@ export function serve(config, opts = {}) {
                 // ready 帧带 server 视角的 machineId/workspaceId → 作为后续所有日志的默认关联键
                 const r = msg;
                 setSlogDefaults({ machine_id: r.machineId, workspace_id: r.workspaceId });
+                // 旧 server 无此字段 → 空集合(daemon 保持全部旧行为)。
+                serverCapabilities = new Set(Array.isArray(r.serverCapabilities)
+                    ? r.serverCapabilities.filter((c) => typeof c === "string")
+                    : []);
+                if (serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)) {
+                    if (await projectSkillsInitialized)
+                        await projectSkillsController.publishCurrent();
+                }
                 return;
             }
             if (msg.type === "error") {
@@ -517,6 +581,22 @@ export function serve(config, opts = {}) {
                 }
                 return;
             }
+            if (msg.type === "project:add"
+                || msg.type === "project:remove"
+                || msg.type === "project:rescan"
+                || msg.type === "agent:skills:sync") {
+                const request = msg;
+                if (typeof request.reqId !== "string")
+                    return;
+                const result = serverCapabilities.has(PROJECT_SKILLS_CAPABILITY)
+                    ? await projectSkillsController.handle(msg)
+                    : { ok: false, error: "capability_unavailable" };
+                try {
+                    ws?.send(JSON.stringify({ type: "fs:result", reqId: request.reqId, ...result }));
+                }
+                catch { /* server 会按请求超时处理 */ }
+                return;
+            }
             // 导入 raft agent 工作区:inspect 反填 name/description;import 复制用户内容
             if (msg.type === "raft:inspect" || msg.type === "raft:import") {
                 const req = msg;
@@ -579,6 +659,9 @@ export function serve(config, opts = {}) {
                         : {}),
                 })
                 : null;
+            // 活取值:发报告的时刻按"当前连接"的 server 能力判定(滚动发布中 run 可能跨重连;
+            // 断线时集合被清空 → 回退为 daemon 自行发通知,方向安全)。
+            const serverOwnsFailureNotice = () => serverCapabilities.has("scheduled_failure_notice_v1");
             const threadId = msg.wake?.threadId;
             const taskKey = scheduled ? scheduled.runId : (threadId ?? msg.channelId);
             const key = `${msg.agentHandle}:${taskKey}`;
@@ -744,6 +827,7 @@ export function serve(config, opts = {}) {
                                 title: scheduled.title,
                                 outputPolicy: scheduled.outputPolicy,
                                 externalNotificationPolicy: scheduled.externalNotificationPolicy,
+                                serverOwnsFailureNotice,
                             },
                         } : {}),
                         ...(wakeOrigin ? { wakeOrigin, originDecisionAttempt: attempt } : {}),
@@ -852,6 +936,7 @@ export function serve(config, opts = {}) {
                             channelId: msg.channelId,
                             scheduled,
                             errorMessage: e.message,
+                            serverOwnsFailureNotice,
                         });
                     }
                     catch { /* token 也不可用时只能让 server 按 runtime failure 终态化 */ }
@@ -889,6 +974,8 @@ export function serve(config, opts = {}) {
         ws.on("close", (code) => {
             if (stopped)
                 return;
+            // server 能力随连接失效;下个连接的 ready 帧重新声明(防降级重连后沿用过期能力)。
+            serverCapabilities = new Set();
             completionRetransmitter.pause();
             // 4001 = 控制面应用级「鉴权失败」关闭码(见 server control-plane.ts)。即使上面的
             // error 帧因 close 抢先而丢失,也能据关闭码识别这是凭证失效——退避拉满,不再每秒热循环。
@@ -926,6 +1013,7 @@ export function serve(config, opts = {}) {
             flush: flushSlog,
             writeStderr: (line) => process.stderr.write(line),
         });
+        projectSkillsAvailable = await projectSkillsInitialized;
         connect();
     })();
     const stop = () => {

package/dist/skill-frontmatter.js

@@ -0,0 +1,23 @@
+export function parseSkillFrontmatter(markdown) {
+    const match = markdown.match(/^---[\t ]*\r?\n([\s\S]*?)\r?\n---(?:[\t ]*\r?\n|$)/u);
+    if (!match)
+        return Object.freeze({});
+    let name;
+    let description;
+    for (const line of match[1]?.split(/\r?\n/u) ?? []) {
+        const field = line.match(/^(name|description)[\t ]*:[\t ]*(.*?)[\t ]*$/u);
+        if (!field)
+            continue;
+        const value = (field[2] ?? "")
+            .replace(/^(?:"([\s\S]*)"|'([\s\S]*)')$/u, "$1$2")
+            .trim();
+        if (field[1] === "name")
+            name = value;
+        if (field[1] === "description")
+            description = value;
+    }
+    return Object.freeze({
+        ...(name === undefined ? {} : { name }),
+        ...(description === undefined ? {} : { description }),
+    });
+}

package/dist/skills.js

@@ -9,25 +9,8 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import { parseSkillFrontmatter } from "./skill-frontmatter.js";
 const globalSkillsDir = () => process.env.CREW_GLOBAL_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
-/** 从 SKILL.md 顶部 YAML frontmatter 取 name / description (简易解析,够用)。 */
-function parseFrontmatter(md) {
-    const m = md.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!m)
-        return {};
-    const out = {};
-    for (const line of m[1].split("\n")) {
-        const kv = line.match(/^(name|description)\s*:\s*(.+?)\s*$/);
-        if (kv) {
-            const val = kv[2].replace(/^["']|["']$/g, "");
-            if (kv[1] === "name")
-                out.name = val;
-            else
-                out.description = val;
-        }
-    }
-    return out;
-}
 async function readSkillsFrom(dir, scope) {
     const names = await readdir(dir).catch(() => []);
     const skills = [];
@@ -39,7 +22,7 @@ async function readSkillsFrom(dir, scope) {
         if (!s || !s.isFile())
             continue;
         const md = await readFile(skillMd, "utf8").catch(() => "");
-        const fm = parseFrontmatter(md);
+        const fm = parseSkillFrontmatter(md);
         skills.push({ scope, name: fm.name || name, description: fm.description ?? "" });
     }
     return skills;

package/dist/supervised-runtime.js

@@ -1,4 +1,5 @@
 import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { startDormantSupervisor, } from "./execution-supervisor.js";
 import { buildClaudeArgs } from "./runtimes/claude.js";
 import { RuntimeCancelledError } from "./runtime-cancellation.js";
@@ -19,6 +20,9 @@ export function supervisorLaunch(request) {
                 cwd: request.cwd,
                 env: request.env,
                 systemPromptPath: request.systemPromptPath,
+                ...(request.agentRoot === undefined ? {} : {
+                    projectSkillsDirectory: join(request.agentRoot, ".crew", "claude-skills"),
+                }),
                 ...(request.sessionId === undefined ? {} : {
                     sessionId: request.sessionId,
                     resume: request.resume,
@@ -45,6 +49,9 @@ export function supervisorLaunch(request) {
                 ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
                 ...(request.sessionId === undefined ? {} : { sessionId: request.sessionId }),
                 ...(request.imagePaths === undefined ? {} : { imagePaths: request.imagePaths }),
+                ...(request.agentRoot === undefined ? {} : {
+                    projectRootMarkers: [".git", ".nowwork-root"],
+                }),
                 resume: request.resume,
             }),
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.5.33",
+  "version": "0.5.35",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",