@nowcrew/daemon 0.6.0 → 0.6.1

package/dist/agent-ability/materializer.js

@@ -3,8 +3,8 @@ import { chmod, cp, lstat, mkdir, readFile, readdir, readlink, rename, rm, symli
 import { dirname, join, relative, resolve, sep } from "node:path";
 import { parse } from "yaml";
 import { dslog } from "../slog.js";
-import { abilitySha256, abilityTreeDigest, collectAbilityFiles, safeAbilityName, } from "./resolver.js";
-import { DaemonAbilityLockSchema, DaemonAbilityManifestSchema } from "./types.js";
+import { abilitySha256, abilityTreeDigest, collectAbilityFiles, resolveAbilityRelease, safeAbilityName, } from "./resolver.js";
+import { abilityWorkspaceProjectionPath, DaemonAbilityLockSchema, DaemonAbilityManifestSchema } from "./types.js";
 const exists = (path) => lstat(path).then(() => true, () => false);
 const repositoryKey = (url) => createHash("sha256").update(url).digest("hex");
 const posixPath = (value) => value.split(sep).join("/");
@@ -48,18 +48,20 @@ const switchDirectory = async (target, staging, backup) => {
         if (hadPrevious)
             await rename(target, backup);
         await rename(staging, target);
-        if (hadPrevious)
+        if (hadPrevious) {
+            await writableTree(backup);
             await rm(backup, { recursive: true, force: true });
+        }
     }
     catch (error) {
         if (await exists(target))
-            await rm(target, { recursive: true, force: true }).catch(() => { });
+            await removeManagedTree(target).catch(() => { });
         if (hadPrevious && await exists(backup))
             await rename(backup, target).catch(() => { });
         throw error;
     }
 };
-const copyExistingSkills = async (target, staging, managedReleaseRoot) => {
+const copyExistingSkills = async (target, staging, managedRoots) => {
     const names = new Set();
     if (!await exists(target))
         return names;
@@ -70,7 +72,7 @@ const copyExistingSkills = async (target, staging, managedReleaseRoot) => {
         if (info.isSymbolicLink()) {
             const link = await readlink(source);
             const resolvedLink = resolve(dirname(source), link);
-            if (resolvedLink === managedReleaseRoot || resolvedLink.startsWith(`${managedReleaseRoot}${sep}`))
+            if (managedRoots.some((root) => resolvedLink === root || resolvedLink.startsWith(`${root}${sep}`)))
                 continue;
             await symlink(link, destination, "dir");
         }
@@ -80,10 +82,10 @@ const copyExistingSkills = async (target, staging, managedReleaseRoot) => {
     }
     return names;
 };
-const projectNativeSkills = async (agentRoot, releaseRoot, skills) => {
+const projectNativeSkills = async (agentRoot, trainingRoot, skills) => {
     const nativeSkills = [];
     for (const skill of skills) {
-        const source = join(releaseRoot, "skills", safeAbilityName(skill.name));
+        const source = join(trainingRoot, "skills", safeAbilityName(skill.name));
         if (await exists(join(source, "SKILL.md"))) {
             nativeSkills.push({ name: skill.name, source });
             continue;
@@ -99,14 +101,14 @@ const projectNativeSkills = async (agentRoot, releaseRoot, skills) => {
         join(agentRoot, ".agents", "skills"),
         join(agentRoot, ".crew", "claude-skills", ".claude", "skills"),
     ];
-    const managedReleaseRoot = join(agentRoot, ".nowcrew", "ability", "releases");
+    const managedRoots = [trainingRoot, join(agentRoot, ".nowcrew", "ability", "releases")];
     for (const target of targets) {
         const staging = join(dirname(target), `.ability-skills-next-${id}`);
         const backup = join(dirname(target), `.ability-skills-previous-${id}`);
         await mkdir(dirname(target), { recursive: true });
         await mkdir(staging, { mode: 0o700 });
         try {
-            const names = await copyExistingSkills(target, staging, managedReleaseRoot);
+            const names = await copyExistingSkills(target, staging, managedRoots);
             for (const skill of nativeSkills) {
                 if (names.has(skill.name))
                     throw new Error(`ability_skill_name_conflict:${skill.name}`);
@@ -192,24 +194,56 @@ const verifyCache = async (agentsRoot, ability) => {
     if (ability.memory.reduce((bytes, memory) => bytes + Buffer.byteLength(memory.content, "utf8"), 0) > 64 * 1024) {
         throw new Error("ability_memory_snapshot_size_exceeded");
     }
-    return root;
+    return { root, manifest };
 };
-const materializeRelease = async (agentsRoot, handle, ability) => {
-    const sourceRoot = await verifyCache(agentsRoot, ability);
+const layerRelativePath = (path, layer) => path.startsWith(`${layer}/`) ? path.slice(layer.length + 1) : path;
+const readManagedCatalog = async (trainingRoot) => JSON.parse(await readFile(join(trainingRoot, "ACTIVE_RELEASE.json"), "utf8"));
+const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
+    let verified;
+    try {
+        verified = await verifyCache(agentsRoot, ability);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || error.message !== "ability_artifact_cache_missing")
+            throw error;
+        const resolved = await resolveAbilityRelease(agentsRoot, {
+            type: "agent:ability:resolve",
+            reqId: `workspace-apply-${ability.releaseId}`,
+            handle,
+            repositoryUrl: ability.repositoryUrl,
+            branchGlob: ability.branch,
+            desiredCommit: ability.rootCommit,
+        });
+        if (resolved.artifactDigest !== ability.artifactDigest || resolved.rootCommit !== ability.rootCommit) {
+            throw new Error("ability_workspace_projection_source_mismatch");
+        }
+        verified = await verifyCache(agentsRoot, ability);
+    }
+    const sourceRoot = verified.root;
     const agentRoot = join(agentsRoot, handle);
-    const abilityRoot = join(agentRoot, ".nowcrew", "ability");
-    const releaseRoot = join(abilityRoot, "releases", ability.releaseId);
-    const catalogPath = join(releaseRoot, "catalog.json");
-    if (await exists(catalogPath)) {
-        const catalog = JSON.parse(await readFile(catalogPath, "utf8"));
-        if (catalog.artifactDigest === ability.artifactDigest)
-            return releaseRoot;
-        await removeManagedTree(releaseRoot);
+    const trainingRoot = join(agentRoot, "training");
+    const projectionDigest = abilitySha256(JSON.stringify({
+        artifactDigest: ability.artifactDigest,
+        memory: ability.memory,
+        workspace: ability.workspace,
+    }));
+    let previousCatalog = null;
+    if (await exists(trainingRoot)) {
+        previousCatalog = await readManagedCatalog(trainingRoot).catch(() => null);
+        if (previousCatalog?.managedBy !== "nowcrew-agent-training") {
+            throw new Error("ability_workspace_training_conflict");
+        }
+        if (previousCatalog.releaseId === ability.releaseId
+            && previousCatalog.artifactDigest === ability.artifactDigest
+            && previousCatalog.projectionDigest === projectionDigest)
+            return trainingRoot;
     }
-    const staging = join(abilityRoot, "releases", `.next-${ability.releaseId}-${randomUUID()}`);
+    await mkdir(agentRoot, { recursive: true });
+    const staging = join(agentRoot, `.training-next-${ability.releaseId}-${randomUUID()}`);
+    const backup = join(agentRoot, `.training-previous-${ability.releaseId}-${randomUUID()}`);
     await mkdir(staging, { recursive: true, mode: 0o700 });
     try {
-        const instructionsTarget = join(staging, "instructions", ability.instructions.path);
+        const instructionsTarget = join(staging, "instructions", layerRelativePath(ability.instructions.path, "instructions"));
         await mkdir(dirname(instructionsTarget), { recursive: true });
         await cp(join(sourceRoot, ability.instructions.path), instructionsTarget, { preserveTimestamps: true });
         for (const skill of ability.skills) {
@@ -223,105 +257,127 @@ const materializeRelease = async (agentsRoot, handle, ability) => {
             await writeFile(target, memory.content, { encoding: "utf8", mode: 0o600 });
         }
         for (const asset of ability.workspace) {
-            const relativeTarget = asset.target.replace(/^\.nowcrew\/ability\//u, "");
+            const relativeTarget = abilityWorkspaceProjectionPath(asset.target);
             const target = join(staging, "workspace", relativeTarget);
             await mkdir(dirname(target), { recursive: true });
-            await cp(join(sourceRoot, asset.source), target, { recursive: true, preserveTimestamps: true });
+            const previous = join(trainingRoot, "workspace", relativeTarget);
+            const source = asset.mode === "managed-copy" && previousCatalog !== null && await exists(previous)
+                ? previous
+                : join(sourceRoot, asset.source);
+            await cp(source, target, { recursive: true, preserveTimestamps: true });
+        }
+        const evalPaths = [verified.manifest.spec.evals.policy, ...verified.manifest.spec.evals.cases];
+        for (const path of evalPaths) {
+            const target = join(staging, "evals", layerRelativePath(path, "evals"));
+            await mkdir(dirname(target), { recursive: true });
+            await cp(join(sourceRoot, path), target, { recursive: true, preserveTimestamps: true });
         }
-        await writeFile(join(staging, "catalog.json"), JSON.stringify({
+        await writeFile(join(staging, "ACTIVE_RELEASE.json"), JSON.stringify({
+            managedBy: "nowcrew-agent-training",
             releaseId: ability.releaseId,
             rootCommit: ability.rootCommit,
             artifactDigest: ability.artifactDigest,
-            instructions: ability.instructions.path,
+            projectionDigest,
+            instructions: `training/instructions/${layerRelativePath(ability.instructions.path, "instructions")}`,
             skills: ability.skills.map((skill) => skill.name),
             memory: ability.memory.map((memory) => ({ id: memory.id, layer: memory.layer })),
-            workspace: ability.workspace,
-            evalProvenance: ability.evalProvenance,
+            workspace: ability.workspace.map((asset) => ({
+                ...asset,
+                projectedPath: `training/workspace/${abilityWorkspaceProjectionPath(asset.target)}`,
+            })),
+            evals: evalPaths.map((path) => `training/evals/${layerRelativePath(path, "evals")}`),
         }, null, 2), { encoding: "utf8", mode: 0o600 });
         await readonlyTree(staging);
-        await rename(staging, releaseRoot);
+        for (const asset of ability.workspace) {
+            if (asset.mode === "managed-copy") {
+                await writableTree(join(staging, "workspace", abilityWorkspaceProjectionPath(asset.target)));
+            }
+        }
+        await switchDirectory(trainingRoot, staging, backup);
     }
     catch (error) {
         await removeManagedTree(staging).catch(() => { });
         throw error;
     }
-    return releaseRoot;
+    return trainingRoot;
 };
-const activatePointerAndWorkspace = async (agentsRoot, handle, ability, releaseRoot) => {
+const projectWorkspaceTraining = async (agentsRoot, handle, ability, trainingRoot) => {
     const agentRoot = join(agentsRoot, handle);
-    const abilityRoot = join(agentRoot, ".nowcrew", "ability");
-    const next = join(abilityRoot, `.current-next-${randomUUID()}`);
-    const previous = join(abilityRoot, `.current-previous-${randomUUID()}`);
-    await mkdir(abilityRoot, { recursive: true });
-    await symlink(releaseRoot, next, "dir");
-    const current = join(abilityRoot, "current");
-    const hadCurrent = await exists(current);
-    if (hadCurrent)
-        await rename(current, previous);
-    try {
-        await rename(next, current);
-        if (hadCurrent)
-            await rm(previous, { recursive: true, force: true });
-    }
-    catch (error) {
-        if (hadCurrent)
-            await rename(previous, current).catch(() => { });
-        throw error;
+    await projectNativeSkills(agentRoot, trainingRoot, ability.skills);
+    const legacyAbilityRoot = join(agentRoot, ".nowcrew", "ability");
+    if (await exists(join(legacyAbilityRoot, "releases")) || await exists(join(legacyAbilityRoot, "current"))) {
+        await removeManagedTree(legacyAbilityRoot);
     }
-    for (const asset of ability.workspace) {
-        const relativeTarget = asset.target.replace(/^\.nowcrew\/ability\//u, "");
-        const source = join(current, "workspace", relativeTarget);
-        const target = join(agentRoot, ...asset.target.split("/"));
-        await mkdir(dirname(target), { recursive: true });
-        if (asset.mode === "managed-copy") {
-            if (!await exists(target))
-                await cp(source, target, { recursive: true, preserveTimestamps: true });
-            continue;
-        }
-        const staging = `${target}.next-${randomUUID()}`;
-        await symlink(source, staging, "dir");
-        if (await exists(target))
-            await rm(target, { recursive: true, force: true });
-        await rename(staging, target);
-    }
-    await projectNativeSkills(agentRoot, releaseRoot, ability.skills);
     await writeFile(join(agentRoot, ".nowwork-root"), "", { encoding: "utf8", mode: 0o600 });
 };
 export function createAgentAbilityMaterializer(expectedAgentsRoot) {
     const tails = new Map();
+    const withAgentTurn = async (handle, operation) => {
+        const previous = tails.get(handle) ?? Promise.resolve();
+        let release;
+        const turn = new Promise((resolveTurn) => { release = resolveTurn; });
+        const tail = previous.then(() => turn);
+        tails.set(handle, tail);
+        await previous;
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (tails.get(handle) === tail)
+                tails.delete(handle);
+        }
+    };
+    const apply = async (agentsRoot, handle, ability) => {
+        if (agentsRoot !== expectedAgentsRoot)
+            throw new Error("ability_agents_root_mismatch");
+        const trainingRoot = await materializeWorkspaceTraining(agentsRoot, handle, ability);
+        await projectWorkspaceTraining(agentsRoot, handle, ability, trainingRoot);
+        return { directory: "training", releaseId: ability.releaseId, artifactDigest: ability.artifactDigest };
+    };
     return {
+        apply(agentsRoot, handle, ability) {
+            return withAgentTurn(handle, async () => {
+                const started = Date.now();
+                try {
+                    const result = await apply(agentsRoot, handle, ability);
+                    dslog("ability.workspace.projected", "Agent training projected into workspace", {
+                        level: "INFO", agent_handle: handle, release_id: ability.releaseId,
+                        root_commit: ability.rootCommit, artifact_digest: ability.artifactDigest,
+                        workspace_directory: result.directory, duration_ms: Date.now() - started,
+                    });
+                    return result;
+                }
+                catch (error) {
+                    dslog("ability.workspace.projection_failed", "Agent training workspace projection failed", {
+                        level: "ERROR", agent_handle: handle, release_id: ability.releaseId,
+                        root_commit: ability.rootCommit,
+                        error_code: error instanceof Error ? error.message.slice(0, 120) : "ability_workspace_projection_failed",
+                    });
+                    throw error;
+                }
+            });
+        },
         async prepareAndLaunch(agentsRoot, handle, ability, launch) {
-            if (agentsRoot !== expectedAgentsRoot)
-                throw new Error("ability_agents_root_mismatch");
-            const previous = tails.get(handle) ?? Promise.resolve();
-            let release;
-            const turn = new Promise((resolveTurn) => { release = resolveTurn; });
-            const tail = previous.then(() => turn);
-            tails.set(handle, tail);
-            await previous;
-            const started = Date.now();
-            try {
-                const releaseRoot = await materializeRelease(agentsRoot, handle, ability);
-                await activatePointerAndWorkspace(agentsRoot, handle, ability, releaseRoot);
-                dslog("ability.execution.materialized", "Agent ability release materialized", {
-                    level: "INFO", agent_handle: handle, release_id: ability.releaseId,
-                    root_commit: ability.rootCommit, artifact_digest: ability.artifactDigest,
-                    duration_ms: Date.now() - started,
-                });
-                return await launch();
-            }
-            catch (error) {
-                dslog("ability.execution.rejected", "Agent ability release materialization failed", {
-                    level: "ERROR", agent_handle: handle, release_id: ability.releaseId,
-                    root_commit: ability.rootCommit, error_code: error instanceof Error ? error.message.slice(0, 120) : "ability_materialization_failed",
-                });
-                throw error;
-            }
-            finally {
-                release();
-                if (tails.get(handle) === tail)
-                    tails.delete(handle);
-            }
+            return withAgentTurn(handle, async () => {
+                const started = Date.now();
+                try {
+                    await apply(agentsRoot, handle, ability);
+                    dslog("ability.execution.materialized", "Agent ability release materialized", {
+                        level: "INFO", agent_handle: handle, release_id: ability.releaseId,
+                        root_commit: ability.rootCommit, artifact_digest: ability.artifactDigest,
+                        workspace_directory: "training", duration_ms: Date.now() - started,
+                    });
+                    return await launch();
+                }
+                catch (error) {
+                    dslog("ability.execution.rejected", "Agent ability release materialization failed", {
+                        level: "ERROR", agent_handle: handle, release_id: ability.releaseId,
+                        root_commit: ability.rootCommit, error_code: error instanceof Error ? error.message.slice(0, 120) : "ability_materialization_failed",
+                    });
+                    throw error;
+                }
+            });
         },
     };
 }

package/dist/agent-ability/resolver.js

@@ -5,7 +5,7 @@ import { dirname, extname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { parse } from "yaml";
 import { z } from "zod";
-import { DaemonAbilityLockSchema, DaemonAbilityManifestSchema, matchesAbilityBranch, } from "./types.js";
+import { abilityWorkspaceProjectionPath, DaemonAbilityLockSchema, DaemonAbilityManifestSchema, matchesAbilityBranch, } from "./types.js";
 const runFile = promisify(execFile);
 const MAX_FILES = 5_000;
 const MAX_TOTAL_BYTES = 25 * 1024 * 1024;
@@ -281,13 +281,14 @@ export const evaluateAbilityCases = (files, manifest, lock, memory) => {
     const workspaceReferenceResolves = (reference) => {
         if (!reference.startsWith("workspace://"))
             return false;
-        const target = `.nowcrew/ability/${reference.slice("workspace://".length)}`;
+        const target = reference.slice("workspace://".length);
         return manifest.spec.workspace.assets.some((asset) => {
-            if (target === asset.target)
+            const projection = abilityWorkspaceProjectionPath(asset.target);
+            if (target === projection)
                 return filePaths.has(asset.source);
-            if (!target.startsWith(`${asset.target}/`))
+            if (!target.startsWith(`${projection}/`))
                 return false;
-            return filePaths.has(`${asset.source}/${target.slice(asset.target.length + 1)}`);
+            return filePaths.has(`${asset.source}/${target.slice(projection.length + 1)}`);
         });
     };
     const assertions = [];

package/dist/agent-ability/runtime.js

@@ -1,20 +1,53 @@
+import { z } from "zod";
+import { AbilityReleaseSnapshotSchema, AgentHandleSchema } from "../execution-protocol.js";
 import { createAgentAbilityController } from "./controller.js";
 import { createAgentAbilityMaterializer } from "./materializer.js";
-import { AGENT_ABILITY_CAPABILITY } from "./types.js";
+import { AGENT_ABILITY_CAPABILITY, AGENT_ABILITY_WORKSPACE_CAPABILITY } from "./types.js";
+const AbilityApplyCommandSchema = z.object({
+    type: z.literal("agent:ability:apply"),
+    reqId: z.string().min(1).max(128),
+    handle: AgentHandleSchema,
+    ability: AbilityReleaseSnapshotSchema,
+}).strict();
 export function createAgentAbilityRuntime(agentsRoot, options = {}) {
     const controller = options.controller ?? createAgentAbilityController({ agentsRoot });
     const materializer = options.materializer ?? createAgentAbilityMaterializer(agentsRoot);
     return {
         materializer,
         async tryHandleControlMessage(input, serverCapabilities, send) {
-            if (input?.type !== "agent:ability:resolve")
+            const type = input?.type;
+            if (type !== "agent:ability:resolve" && type !== "agent:ability:apply")
                 return false;
             const reqId = input.reqId;
             if (typeof reqId !== "string")
                 return true;
-            const result = serverCapabilities.has(AGENT_ABILITY_CAPABILITY)
-                ? await controller.handle(input)
-                : { ok: false, error: "capability_unavailable" };
+            let result;
+            const requiredCapability = type === "agent:ability:apply"
+                ? AGENT_ABILITY_WORKSPACE_CAPABILITY
+                : AGENT_ABILITY_CAPABILITY;
+            if (!serverCapabilities.has(requiredCapability)) {
+                result = { ok: false, error: "capability_unavailable" };
+            }
+            else if (type === "agent:ability:resolve") {
+                result = await controller.handle(input);
+            }
+            else {
+                const parsed = AbilityApplyCommandSchema.safeParse(input);
+                if (!parsed.success)
+                    result = { ok: false, error: "invalid_ability_apply_command" };
+                else {
+                    try {
+                        result = { ok: true, data: await materializer.apply(agentsRoot, parsed.data.handle, parsed.data.ability) };
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : "ability_workspace_projection_failed";
+                        result = {
+                            ok: false,
+                            error: /^[a-z0-9_:-]+$/u.test(message) ? message.slice(0, 200) : "ability_workspace_projection_failed",
+                        };
+                    }
+                }
+            }
             try {
                 send({ type: "fs:result", reqId, ...result });
             }

package/dist/agent-ability/types.js

@@ -1,10 +1,17 @@
 import { z } from "zod";
 export const AGENT_ABILITY_CAPABILITY = "agent_ability_release_v1";
+export const AGENT_ABILITY_WORKSPACE_CAPABILITY = "agent_ability_workspace_v1";
 const DigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
 const CommitSchema = z.string().regex(/^[a-f0-9]{40}$/u);
 export const SafeAbilityPathSchema = z.string().min(1).max(512).refine((value) => !value.startsWith("/") && !value.includes("\\") && !value.includes("\0")
     && value.split("/").every((part) => part.length > 0 && part !== "." && part !== ".."), "unsafe ability path");
-export const WorkspaceAbilityTargetSchema = SafeAbilityPathSchema.refine((value) => value.startsWith(".nowcrew/ability/"), "training workspace targets must stay under .nowcrew/ability/");
+export const WorkspaceAbilityTargetSchema = SafeAbilityPathSchema.refine((value) => value.startsWith("training/workspace/") || value.startsWith(".nowcrew/ability/"), "training workspace targets must stay under training/workspace/");
+export function abilityWorkspaceProjectionPath(target) {
+    WorkspaceAbilityTargetSchema.parse(target);
+    return target.startsWith("training/workspace/")
+        ? target.slice("training/workspace/".length)
+        : target.slice(".nowcrew/ability/".length);
+}
 export const AbilityRepositoryUrlSchema = z.string().trim().min(1).max(2_048).superRefine((value, ctx) => {
     const scpLike = /^git@[a-z0-9.-]+:[A-Za-z0-9._~/-]+(?:\.git)?$/iu.test(value);
     let allowedUrl = false;
@@ -30,12 +37,11 @@ export function matchesAbilityBranch(glob, branch) {
     let pattern = "^";
     for (let index = 0; index < glob.length; index += 1) {
         const character = glob[index];
-        if (character === "*" && glob[index + 1] === "*") {
+        if (character === "*") {
             pattern += ".*";
-            index += 1;
+            if (glob[index + 1] === "*")
+                index += 1;
         }
-        else if (character === "*")
-            pattern += "[^/]*";
         else
             pattern += character.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
     }

package/dist/execution-protocol.js

@@ -23,7 +23,7 @@ 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();
-const AbilityReleaseSnapshotSchema = z.object({
+export const AbilityReleaseSnapshotSchema = z.object({
     bindingId: z.string().uuid(),
     releaseId: z.string().uuid(),
     repositoryUrl: AbilityRepositoryUrlSchema,

package/dist/machine-info.js

@@ -34,11 +34,13 @@ export const DAEMON_CAPABILITIES = [
     "project_skills_v1",
     RUNTIME_HEALTH_PROBE_CAPABILITY,
     "agent_ability_release_v1",
+    "agent_ability_workspace_v1",
 ];
 export const daemonCapabilities = (runtimePlatform = process.platform) => runtimePlatform === "darwin" || runtimePlatform === "linux"
     ? DAEMON_CAPABILITIES
     : DAEMON_CAPABILITIES.filter((capability) => capability !== "project_skills_v1"
-        && capability !== "agent_ability_release_v1");
+        && capability !== "agent_ability_release_v1"
+        && capability !== "agent_ability_workspace_v1");
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
 const RUNTIME_BINS = [

package/package.json

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