@nowcrew/daemon 0.6.10 → 0.6.12

package/dist/agent-ability/materializer.js

@@ -440,8 +440,6 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
             for (const mount of mounts) {
                 const sources = verified.files.filter((file) => file.path.endsWith(".md")
                     && (file.path === mount.path || file.path.startsWith(`${mount.path}/`)));
-                if (sources.length === 0)
-                    throw new Error(`ability_memory_mount_empty:${mount.path}`);
                 for (const source of sources) {
                     const relativePath = source.path === mount.path
                         ? source.path.split("/").at(-1)
@@ -467,7 +465,10 @@ const materializeWorkspaceTraining = async (agentsRoot, handle, ability) => {
                 : join(sourceRoot, asset.source);
             await cp(source, target, { recursive: true, preserveTimestamps: true });
         }
-        const evalPaths = [verified.manifest.spec.evals.policy, ...verified.manifest.spec.evals.cases];
+        const evalPaths = [
+            ...(verified.manifest.spec.evals.policy === undefined ? [] : [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 });

package/dist/agent-ability/resolver.js

@@ -253,9 +253,19 @@ const scan = (files, manifest) => {
         if (executable.has(extname(file.path).toLowerCase()))
             findings.push({ code: "executable_asset", path: file.path });
     }
-    const required = new Set(["instructions", "memory-policy", "memory-seed", "workspace", "eval-policy", "eval-cases"]);
+    const required = new Set(["instructions"]);
     if (manifest.spec.skills.length > 0)
         required.add("skills");
+    if (manifest.spec.memory.policy.length > 0)
+        required.add("memory-policy");
+    if (manifest.spec.memory.seeds.length > 0)
+        required.add("memory-seed");
+    if (manifest.spec.workspace.assets.length > 0)
+        required.add("workspace");
+    if (manifest.spec.evals.policy !== undefined)
+        required.add("eval-policy");
+    if (manifest.spec.evals.cases.length > 0)
+        required.add("eval-cases");
     return { findings, required };
 };
 const lockedManifestPaths = (manifest) => [
@@ -264,7 +274,7 @@ const lockedManifestPaths = (manifest) => [
     ...manifest.spec.memory.policy.map((entry) => entry.path),
     ...manifest.spec.memory.seeds.map((entry) => entry.path),
     ...manifest.spec.workspace.assets.map((entry) => entry.source),
-    manifest.spec.evals.policy,
+    ...(manifest.spec.evals.policy === undefined ? [] : [manifest.spec.evals.policy]),
     ...manifest.spec.evals.cases,
 ];
 export const evaluateAbilityCases = (files, manifest, lock, memory) => {
@@ -367,7 +377,7 @@ export async function resolveAbilityRelease(agentsRoot, command) {
     const assertions = [
         { name: "manifest_lock_verified", passed: true },
         { name: "manifest_asset_paths_locked", passed: lockedManifestPaths(manifest).every((path) => lockedPaths.has(path)) },
-        { name: "all_five_layers_resolvable", passed: [...security.required].every((kind) => kind === "skills" ? kinds.has(kind) || (manifest.spec.skills.length > 0 && lock.dependencies.length > 0) : kinds.has(kind)) },
+        { name: "declared_layers_resolvable", passed: [...security.required].every((kind) => kind === "skills" ? kinds.has(kind) || (manifest.spec.skills.length > 0 && lock.dependencies.length > 0) : kinds.has(kind)) },
         { name: "dependencies_pinned", passed: lock.dependencies.every((dependency) => /^[a-f0-9]{40}$/u.test(dependency.commit)) },
         { name: "security_scan_clear", passed: security.findings.length === 0 },
         ...evaluateAbilityCases(files, manifest, lock, memory),

package/dist/agent-ability/types.js

@@ -61,16 +61,20 @@ export const DaemonAbilityManifestSchema = z.object({
         skills: z.array(z.object({
             name: z.string().min(1).max(128), source: z.union([LocalSkillSchema, GitSkillSchema]),
             mount: SafeAbilityPathSchema, mode: ModeSchema, trust: z.string().max(128).optional(),
-        }).strict()).max(500),
+        }).strict()).max(500).default([]),
         memory: z.object({
-            policy: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(100),
-            seeds: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(1_000),
-            runtime: z.object({ store: z.literal("nowcrew-managed"), promotion: z.literal("pull-request"), retentionDays: z.number().int().positive().optional() }).strict(),
-        }).strict(),
+            policy: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(100).default([]),
+            seeds: z.array(z.object({ path: SafeAbilityPathSchema, mode: ModeSchema, mergeKey: z.string().optional() }).strict()).max(1_000).default([]),
+            runtime: z.object({ store: z.literal("nowcrew-managed"), promotion: z.literal("pull-request"), retentionDays: z.number().int().positive().optional() }).strict()
+                .default({ store: "nowcrew-managed", promotion: "pull-request" }),
+        }).strict().default({ policy: [], seeds: [], runtime: { store: "nowcrew-managed", promotion: "pull-request" } }),
         workspace: z.object({ assets: z.array(z.object({
                 source: SafeAbilityPathSchema, target: WorkspaceAbilityTargetSchema, mode: ModeSchema,
-            }).strict()).max(1_000) }).strict(),
-        evals: z.object({ policy: SafeAbilityPathSchema, cases: z.array(SafeAbilityPathSchema).min(1).max(1_000) }).strict(),
+            }).strict()).max(1_000).default([]) }).strict().default({ assets: [] }),
+        evals: z.object({
+            policy: SafeAbilityPathSchema.optional(),
+            cases: z.array(SafeAbilityPathSchema).max(1_000).default([]),
+        }).strict().default({ cases: [] }),
         compatibility: z.object({
             providers: z.array(z.enum(["claude", "codex", "kimi", "hermes", "opencode", "deepseek-harness"])).min(1),
             minNowCrewVersion: z.string().regex(/^\d+\.\d+\.\d+$/u),

package/dist/local-executor.js

@@ -788,6 +788,16 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                         changes_truncated: changesTruncated,
                         evidence_complete: noteDiff.evidence_complete
                             && !changesTruncated,
+                        before_manifest_error: noteDiff.before_manifest.error,
+                        after_manifest_error: noteDiff.after_manifest.error,
+                        before_manifest_truncated: noteDiff.before_manifest.truncated,
+                        after_manifest_truncated: noteDiff.after_manifest.truncated,
+                        before_total_count: noteDiff.before_manifest.total_count,
+                        after_total_count: noteDiff.after_manifest.total_count,
+                        before_omitted_count: noteDiff.before_manifest.omitted_count,
+                        after_omitted_count: noteDiff.after_manifest.omitted_count,
+                        before_incomplete_file_count: noteDiff.before_manifest.incomplete_file_count,
+                        after_incomplete_file_count: noteDiff.after_manifest.incomplete_file_count,
                         changes: serializedChanges.json,
                     });
                     const postcondition = evaluateMemoryPrunePostcondition(memoryPruneBeforeSnapshot, snapshot, {

package/dist/memory-prune-diagnostics.js

@@ -266,45 +266,69 @@ function fileChanged(before, after) {
     }
     return before.size !== after.size || before.mtime_ms !== after.mtime_ms;
 }
+function notePresence(file) {
+    if (file === undefined)
+        return "absent";
+    if (file.exists)
+        return "present";
+    if (!file.exists && (file.error === undefined || file.error === "ENOENT"))
+        return "absent";
+    return "unknown";
+}
 export function diffMemoryPruneNotes(before, after) {
-    const beforeByPath = new Map(before.files
-        .filter((file) => file.exists)
-        .map((file) => [file.relative_path, file]));
-    const afterByPath = new Map(after.files
-        .filter((file) => file.exists)
-        .map((file) => [file.relative_path, file]));
+    const manifestDiagnostics = (manifest) => ({
+        total_count: manifest.total_count,
+        omitted_count: manifest.omitted_count,
+        truncated: manifest.truncated,
+        incomplete_file_count: manifest.files.filter((file) => !file.exists
+            || file.sha256 === undefined
+            || file.error !== undefined
+            || file.hash_skipped_reason !== undefined).length,
+        ...(manifest.error === undefined ? {} : { error: manifest.error }),
+    });
+    const beforeDiagnostics = manifestDiagnostics(before);
+    const afterDiagnostics = manifestDiagnostics(after);
+    const beforeByPath = new Map(before.files.map((file) => [file.relative_path, file]));
+    const afterByPath = new Map(after.files.map((file) => [file.relative_path, file]));
     const paths = [...new Set([...beforeByPath.keys(), ...afterByPath.keys()])]
         .sort(compareCodeUnits);
     const allChanges = [];
-    for (const relativePath of paths) {
-        const beforeFile = beforeByPath.get(relativePath);
-        const afterFile = afterByPath.get(relativePath);
-        if (beforeFile === undefined && afterFile !== undefined) {
-            allChanges.push({
-                relative_path: relativePath,
-                change: "created",
-                ...(afterFile.sha256 === undefined ? {} : { after_sha256: afterFile.sha256 }),
-                ...(afterFile.size === undefined ? {} : { after_size: afterFile.size }),
-            });
-        }
-        else if (beforeFile !== undefined && afterFile === undefined) {
-            allChanges.push({
-                relative_path: relativePath,
-                change: "deleted",
-                ...(beforeFile.sha256 === undefined ? {} : { before_sha256: beforeFile.sha256 }),
-                ...(beforeFile.size === undefined ? {} : { before_size: beforeFile.size }),
-            });
-        }
-        else if (beforeFile !== undefined && afterFile !== undefined
-            && fileChanged(beforeFile, afterFile)) {
-            allChanges.push({
-                relative_path: relativePath,
-                change: "updated",
-                ...(beforeFile.sha256 === undefined ? {} : { before_sha256: beforeFile.sha256 }),
-                ...(afterFile.sha256 === undefined ? {} : { after_sha256: afterFile.sha256 }),
-                ...(beforeFile.size === undefined ? {} : { before_size: beforeFile.size }),
-                ...(afterFile.size === undefined ? {} : { after_size: afterFile.size }),
-            });
+    if (before.error === undefined && after.error === undefined) {
+        const presenceDiffIsReliable = !before.truncated && !after.truncated;
+        for (const relativePath of paths) {
+            const beforeFile = beforeByPath.get(relativePath);
+            const afterFile = afterByPath.get(relativePath);
+            const beforePresence = notePresence(beforeFile);
+            const afterPresence = notePresence(afterFile);
+            if (presenceDiffIsReliable && beforePresence === "absent" && afterPresence === "present"
+                && afterFile !== undefined) {
+                allChanges.push({
+                    relative_path: relativePath,
+                    change: "created",
+                    ...(afterFile.sha256 === undefined ? {} : { after_sha256: afterFile.sha256 }),
+                    ...(afterFile.size === undefined ? {} : { after_size: afterFile.size }),
+                });
+            }
+            else if (presenceDiffIsReliable && beforePresence === "present" && afterPresence === "absent"
+                && beforeFile !== undefined) {
+                allChanges.push({
+                    relative_path: relativePath,
+                    change: "deleted",
+                    ...(beforeFile.sha256 === undefined ? {} : { before_sha256: beforeFile.sha256 }),
+                    ...(beforeFile.size === undefined ? {} : { before_size: beforeFile.size }),
+                });
+            }
+            else if (beforePresence === "present" && afterPresence === "present"
+                && beforeFile !== undefined && afterFile !== undefined && fileChanged(beforeFile, afterFile)) {
+                allChanges.push({
+                    relative_path: relativePath,
+                    change: "updated",
+                    ...(beforeFile.sha256 === undefined ? {} : { before_sha256: beforeFile.sha256 }),
+                    ...(afterFile.sha256 === undefined ? {} : { after_sha256: afterFile.sha256 }),
+                    ...(beforeFile.size === undefined ? {} : { before_size: beforeFile.size }),
+                    ...(afterFile.size === undefined ? {} : { after_size: afterFile.size }),
+                });
+            }
         }
     }
     return {
@@ -315,10 +339,12 @@ export function diffMemoryPruneNotes(before, after) {
             && after.error === undefined
             && !before.truncated
             && !after.truncated
-            && [...before.files, ...after.files].every((file) => file.exists
-                && file.sha256 !== undefined
-                && file.error === undefined
-                && file.hash_skipped_reason === undefined),
+            && before.omitted_count === 0
+            && after.omitted_count === 0
+            && beforeDiagnostics.incomplete_file_count === 0
+            && afterDiagnostics.incomplete_file_count === 0,
+        before_manifest: beforeDiagnostics,
+        after_manifest: afterDiagnostics,
     };
 }
 export function evaluateMemoryPrunePostcondition(before, after, execution) {

package/package.json

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