@nowcrew/daemon 0.6.9 → 0.6.11

package/dist/diagnostic-json.js

@@ -0,0 +1,14 @@
+export const DIAGNOSTIC_JSON_STRING_LIMIT = 3_800;
+export function boundedDiagnosticJsonArray(items, limit = DIAGNOSTIC_JSON_STRING_LIMIT) {
+    const selected = [];
+    for (const item of items) {
+        const candidate = JSON.stringify([...selected, item]);
+        if (candidate.length > limit)
+            break;
+        selected.push(item);
+    }
+    return {
+        json: JSON.stringify(selected),
+        truncated: selected.length < items.length,
+    };
+}

package/dist/local-executor.js

@@ -18,12 +18,13 @@ import { routeRuntimeAttachments, runtimeCapability, } from "./runtime-capabilit
 import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
 import { isRuntimeReadyEvent, } from "./runtime-startup-gate.js";
 import { dslog } from "./slog.js";
-import { evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
+import { boundedDiagnosticJsonArray } from "./diagnostic-json.js";
+import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
-function memoryPruneSnapshotFields(snapshot) {
+function memoryPruneFileFactFields(fileFacts) {
     const fields = {};
-    for (const [label, fact] of Object.entries(snapshot)) {
+    for (const [label, fact] of Object.entries(fileFacts)) {
         fields[`${label}_exists`] = fact.exists;
         fields[`${label}_size`] = fact.size;
         fields[`${label}_mtime_ms`] = fact.mtime_ms;
@@ -36,6 +37,9 @@ function memoryPruneSnapshotFields(snapshot) {
     }
     return fields;
 }
+function memoryPruneSnapshotFields({ notes_manifest: _notesManifest, ...fileFacts }) {
+    return memoryPruneFileFactFields(fileFacts);
+}
 function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {
     const errorCode = error?.code;
     dslog("memory_prune.diagnostics_failed", "长期记忆收尾诊断失败", {
@@ -772,6 +776,30 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     ...memoryPruneSnapshotFields(snapshot),
                 });
                 if (memoryPruneBeforeSnapshot !== null) {
+                    const noteDiff = diffMemoryPruneNotes(memoryPruneBeforeSnapshot.notes_manifest, snapshot.notes_manifest);
+                    const serializedChanges = boundedDiagnosticJsonArray(noteDiff.changes);
+                    const changesTruncated = noteDiff.truncated || serializedChanges.truncated;
+                    dslog("memory_prune.notes_changed", "长期记忆功能文件变化已评估", {
+                        execution_id: input.executionId,
+                        agent_handle: input.handle,
+                        task_key: input.taskKey,
+                        prune_trace_id: memoryPruneTraceId,
+                        change_count: noteDiff.change_count,
+                        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, {
                         executorCompleted: memoryPruneExecutorCompleted,
                         ...(memoryPruneRuntimeExitCode === undefined

package/dist/local-memory-diagnostics.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
-import { isAbsolute, join, normalize, resolve } from "node:path";
+import { isAbsolute, join, normalize, relative, resolve } from "node:path";
 import { capMemoryForInject, MEMORY_INJECT_CAP } from "./prompt.js";
 const INJECTION_MARKERS = [
     "## Injected MEMORY.md (bounded local context)\n",
@@ -134,50 +134,71 @@ function classifyExplicitPath(path, paths) {
         .replace(/^\$CREW_HOME/, paths.homeDir);
     const absolute = normalized(isAbsolute(replaced) ? replaced : resolve(paths.runDir, replaced));
     if (absolute === paths.sharedMemory)
-        return "shared_memory";
+        return { target: "shared_memory" };
     if (absolute === paths.sharedLessons)
-        return "shared_lessons";
-    if (absolute === paths.cwdMemory && paths.cwdMemory !== paths.sharedMemory)
-        return "cwd_shadow_memory";
-    if (absolute === paths.cwdLessons && paths.cwdLessons !== paths.sharedLessons)
-        return "cwd_shadow_lessons";
-    if (absolute.startsWith(`${paths.sharedNotes}/`))
-        return "other_shared_note";
-    return null;
-}
-function commandTargets(command, paths) {
-    const targets = new Set();
-    const expandedCommand = command
-        .replaceAll("${CREW_HOME}", paths.homeDir)
-        .replaceAll("$CREW_HOME", paths.homeDir)
-        .replace(/["']/g, "");
-    const references = [
-        { values: [paths.sharedMemory], target: "shared_memory" },
-        { values: [paths.sharedLessons], target: "shared_lessons" },
-        { values: [paths.cwdMemory], target: "cwd_shadow_memory" },
-        { values: [paths.cwdLessons], target: "cwd_shadow_lessons" },
-    ];
-    for (const reference of references) {
-        if (reference.values.some((value) => expandedCommand.includes(value)))
-            targets.add(reference.target);
+        return { target: "shared_lessons" };
+    if (absolute === paths.cwdMemory && paths.cwdMemory !== paths.sharedMemory) {
+        return { target: "cwd_shadow_memory" };
     }
-    const withoutKnownPaths = references.flatMap((reference) => reference.values)
-        .reduce((value, reference) => value.replaceAll(reference, ""), expandedCommand);
-    if (/(?:^|[\s'"`])notes[\\/]lessons\.md(?:$|[\s'"`;|&])/i.test(withoutKnownPaths)) {
-        targets.add("cwd_shadow_lessons");
+    if (absolute === paths.cwdLessons && paths.cwdLessons !== paths.sharedLessons) {
+        return { target: "cwd_shadow_lessons" };
     }
-    else if (/(?:^|[\s'"`])MEMORY\.md(?:$|[\s'"`;|&])/i.test(withoutKnownPaths)) {
-        targets.add("cwd_shadow_memory");
+    const relativePath = normalized(relative(paths.homeDir, absolute));
+    const relativeSegments = relativePath.split("/");
+    if (relativeSegments.length === 2
+        && relativeSegments[0] === "notes"
+        && relativeSegments[1]?.toLowerCase().endsWith(".md")) {
+        return { target: "other_shared_note", relative_path: relativePath };
     }
-    return [...targets];
+    return null;
 }
 function commandOperation(command) {
-    if (/(?:^|[;&|]\s*|\s)(?:rm|unlink)\s/i.test(command))
+    if (/[;|&\n]/.test(command))
+        return null;
+    const executable = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*=\S+\s+)*([^\s]+)/
+        .exec(command)?.[1]?.split("/").at(-1)?.toLowerCase();
+    if (executable === undefined)
+        return null;
+    if (["rm", "unlink"].includes(executable))
         return "delete";
-    if (/(?:>>?|\btee\b|\btouch\b|\btruncate\b|\bsed\s+-i\b|\bperl\b[^\n]*\s-i\b|\bapply_patch\b)/i.test(command)) {
+    if (["tee", "touch", "truncate"].includes(executable))
         return "write";
+    if (executable === "sed" || executable === "perl") {
+        return /(?:^|\s)-i\S*(?:\s|$)/.test(command)
+            ? "write"
+            : "read";
+    }
+    return ["cat", "rg", "grep", "head", "tail", "less", "more", "wc", "awk"].includes(executable)
+        ? "read"
+        : null;
+}
+function commandAccesses(command, paths) {
+    if (/[;|&\n]/.test(command))
+        return [];
+    const accesses = new Map();
+    const expanded = command
+        .replaceAll("${CREW_HOME}", paths.homeDir)
+        .replaceAll("$CREW_HOME", paths.homeDir)
+        .replace(/["']/g, "");
+    const redirect = /^(.*?)\s+>>?\s*([^\s]+)\s*$/.exec(expanded);
+    const sourceCommand = redirect?.[1] ?? expanded;
+    const operation = commandOperation(sourceCommand);
+    if (operation !== null) {
+        for (const path of sourceCommand.split(/[\s<>]+/)) {
+            const classified = classifyExplicitPath(path, paths);
+            if (classified === null)
+                continue;
+            accesses.set(`${classified.target}:${classified.relative_path ?? ""}:${operation}`, { ...classified, operation });
+        }
+    }
+    const redirectTarget = redirect?.[2];
+    if (redirectTarget !== undefined) {
+        const classified = classifyExplicitPath(redirectTarget, paths);
+        if (classified !== null) {
+            accesses.set(`${classified.target}:${classified.relative_path ?? ""}:write`, { ...classified, operation: "write" });
+        }
     }
-    return "read";
+    return [...accesses.values()];
 }
 function toolOperation(name) {
     const lowered = name.toLowerCase();
@@ -224,9 +245,9 @@ export function createLocalMemoryAccessObserver(options) {
                         continue;
                     const operation = toolOperation(block.name);
                     const path = toolPath(block.input);
-                    const target = operation === null || path === null ? null : classifyExplicitPath(path, paths);
-                    if (operation !== null && target !== null)
-                        pending.set(block.id, { operation, target });
+                    const classified = operation === null || path === null ? null : classifyExplicitPath(path, paths);
+                    if (operation !== null && classified !== null)
+                        pending.set(block.id, { operation, ...classified });
                 }
             }
             if (record.type === "user") {
@@ -252,11 +273,11 @@ export function createLocalMemoryAccessObserver(options) {
                     ? toolOperation(record.title)
                     : null);
                 const path = toolPath(record.input);
-                const target = fallbackOperation === null || path === null
+                const classified = fallbackOperation === null || path === null
                     ? null
                     : classifyExplicitPath(path, paths);
-                if (fallbackOperation !== null && target !== null) {
-                    pending.set(record.id, { operation: fallbackOperation, target });
+                if (fallbackOperation !== null && classified !== null) {
+                    pending.set(record.id, { operation: fallbackOperation, ...classified });
                 }
             }
             if (record.type === "kimi.acp.tool_result" && typeof record.id === "string") {
@@ -276,7 +297,6 @@ export function createLocalMemoryAccessObserver(options) {
                 ? record.item
                 : null;
             if (item?.type === "command_execution" && typeof item.command === "string") {
-                const operation = commandOperation(item.command);
                 const outcome = typeof item.exit_code === "number"
                     ? item.exit_code === 0 ? "succeeded" : "failed"
                     : item.status === "completed"
@@ -284,8 +304,12 @@ export function createLocalMemoryAccessObserver(options) {
                         : item.status === "failed" || item.status === "declined"
                             ? "failed"
                             : "unknown";
-                for (const target of commandTargets(item.command, paths)) {
-                    recordObservation(observations, counts, { target, operation, outcome, evidence: "shell_command" });
+                for (const access of commandAccesses(item.command, paths)) {
+                    recordObservation(observations, counts, {
+                        ...access,
+                        outcome,
+                        evidence: "shell_command",
+                    });
                 }
             }
             const fileChange = record.type === "diagnostic.file_change" && Array.isArray(record.changes)
@@ -305,11 +329,11 @@ export function createLocalMemoryAccessObserver(options) {
                     const detail = change;
                     if (typeof detail.path !== "string")
                         continue;
-                    const target = classifyExplicitPath(detail.path, paths);
-                    if (target === null)
+                    const classified = classifyExplicitPath(detail.path, paths);
+                    if (classified === null)
                         continue;
                     recordObservation(observations, counts, {
-                        target,
+                        ...classified,
                         operation: detail.kind === "delete" ? "delete" : "write",
                         outcome,
                         evidence: "file_change",

package/dist/local-memory-telemetry.js

@@ -86,6 +86,7 @@ export function createLocalMemoryTelemetry(options) {
     let runtimeReady = false;
     let runtimeExitCode;
     let executorCompleted = false;
+    let sharedMutationObserved = false;
     return {
         async captureBefore() {
             const startedAt = Date.now();
@@ -140,6 +141,14 @@ export function createLocalMemoryTelemetry(options) {
         observe(event) {
             try {
                 for (const observation of accessObserver.observe(event)) {
+                    const isSharedMutation = observation.outcome === "succeeded"
+                        && (observation.operation === "write" || observation.operation === "delete")
+                        && (observation.target === "shared_memory"
+                            || observation.target === "shared_lessons"
+                            || observation.target === "other_shared_note");
+                    if (isSharedMutation) {
+                        sharedMutationObserved = true;
+                    }
                     accessSequence += 1;
                     logAccess(options, observation, accessSequence);
                 }
@@ -178,8 +187,6 @@ export function createLocalMemoryTelemetry(options) {
             const sharedFilesChanged = memoryChanged === undefined || lessonsChanged === undefined
                 ? undefined
                 : memoryChanged || lessonsChanged;
-            const currentExecutionSharedWriteObserved = accessSummary.shared_memory_write_succeeded > 0
-                || accessSummary.shared_lessons_write_succeeded > 0;
             safeLog("local_memory.execution_observed", "本地记忆执行观察已完成", {
                 execution_id: options.executionId,
                 agent_handle: options.agentHandle,
@@ -196,7 +203,7 @@ export function createLocalMemoryTelemetry(options) {
                 shared_files_changed_during_execution: sharedFilesChanged,
                 unexpected_shared_write: options.isMemoryPrune
                     ? undefined
-                    : currentExecutionSharedWriteObserved
+                    : sharedMutationObserved
                         ? true
                         : sharedFilesChanged === false ? false : undefined,
                 access_observation_count: accessSequence,

package/dist/memory-prune-diagnostics.js

@@ -1,17 +1,22 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { stat } from "node:fs/promises";
+import { lstat, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 const TRACE_PATTERN = /\[memory-prune trace_id=([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\]/i;
 export const MEMORY_PRUNE_HASH_LIMIT_BYTES = 10 * 1024 * 1024;
+export const MEMORY_PRUNE_NOTES_MANIFEST_LIMIT = 128;
+export const MEMORY_PRUNE_NOTE_CHANGE_LIMIT = 128;
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
 export function parseMemoryPruneTraceId(wakePrompt) {
     return TRACE_PATTERN.exec(wakePrompt)?.[1] ?? null;
 }
 async function inspectFile(path, markdownFacts = false, sameAsSharedPath, signal) {
     let metadata;
     try {
-        metadata = await stat(path);
+        metadata = await lstat(path);
     }
     catch (error) {
         const code = error.code;
@@ -32,6 +37,8 @@ async function inspectFile(path, markdownFacts = false, sameAsSharedPath, signal
         mtime_ms: metadata.mtimeMs,
         ...(sameAsSharedPath === undefined ? {} : { same_as_shared_path: sameAsSharedPath }),
     };
+    if (metadata.isSymbolicLink())
+        return { ...fact, error: "symbolic_link" };
     if (!metadata.isFile())
         return { ...fact, hash_skipped_reason: "not_regular_file" };
     if (metadata.size > MEMORY_PRUNE_HASH_LIMIT_BYTES) {
@@ -91,13 +98,106 @@ async function inspectFile(path, markdownFacts = false, sameAsSharedPath, signal
         return { ...fact, error: code ?? (error instanceof Error ? error.name : "unknown") };
     }
 }
-export async function inspectMemoryPruneFiles(homeDir, runDir, workLogPath, signal) {
+function diagnosticError(error) {
+    const code = error.code;
+    return code ?? (error instanceof Error ? error.name : "unknown");
+}
+async function inspectLessonsFile(rootDir, sameAsSharedPath, signal) {
+    const pathFact = sameAsSharedPath === undefined ? {} : { same_as_shared_path: sameAsSharedPath };
+    try {
+        const notesMetadata = await lstat(join(rootDir, "notes"));
+        if (notesMetadata.isSymbolicLink()) {
+            return { exists: false, ...pathFact, error: "symbolic_link" };
+        }
+        if (!notesMetadata.isDirectory())
+            return { exists: false, ...pathFact, error: "ENOTDIR" };
+    }
+    catch (error) {
+        const code = diagnosticError(error);
+        return code === "ENOENT"
+            ? { exists: false, ...pathFact }
+            : { exists: false, ...pathFact, error: code };
+    }
+    return inspectFile(join(rootDir, "notes", "lessons.md"), true, sameAsSharedPath, signal);
+}
+export async function inspectMemoryPruneNotes(homeDir, signal) {
+    const notesDir = join(homeDir, "notes");
+    try {
+        const metadata = await lstat(notesDir);
+        if (metadata.isSymbolicLink()) {
+            return {
+                files: [], total_count: 0, omitted_count: 0, truncated: false, error: "symbolic_link",
+            };
+        }
+        if (!metadata.isDirectory()) {
+            return {
+                files: [], total_count: 0, omitted_count: 0, truncated: false, error: "ENOTDIR",
+            };
+        }
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return { files: [], total_count: 0, omitted_count: 0, truncated: false };
+        }
+        return {
+            files: [],
+            total_count: 0,
+            omitted_count: 0,
+            truncated: false,
+            error: diagnosticError(error),
+        };
+    }
+    let noteNames;
+    try {
+        noteNames = (await readdir(notesDir, { withFileTypes: true }))
+            .filter((entry) => (entry.isFile() || entry.isSymbolicLink())
+            && entry.name.toLowerCase().endsWith(".md"))
+            .map((entry) => entry.name)
+            .sort(compareCodeUnits);
+    }
+    catch (error) {
+        return {
+            files: [], total_count: 0, omitted_count: 0, truncated: false,
+            error: diagnosticError(error),
+        };
+    }
+    const totalCount = noteNames.length;
+    const selected = noteNames.slice(0, MEMORY_PRUNE_NOTES_MANIFEST_LIMIT);
+    const files = [];
+    for (const name of selected) {
+        if (signal?.aborted)
+            break;
+        const path = join(notesDir, name);
+        try {
+            if ((await lstat(path)).isSymbolicLink()) {
+                files.push({ relative_path: `notes/${name}`, exists: false, error: "symbolic_link" });
+                continue;
+            }
+        }
+        catch (error) {
+            files.push({ relative_path: `notes/${name}`, exists: false, error: diagnosticError(error) });
+            continue;
+        }
+        files.push({
+            relative_path: `notes/${name}`,
+            ...await inspectFile(path, false, undefined, signal),
+        });
+    }
+    return {
+        files,
+        total_count: totalCount,
+        omitted_count: Math.max(0, totalCount - selected.length),
+        truncated: totalCount > selected.length,
+        ...(signal?.aborted ? { error: "ABORT_ERR" } : {}),
+    };
+}
+async function inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal) {
     const cwdIsHome = runDir === homeDir;
     const [memory, lessons, cwdMemory, cwdLessons, workLog] = await Promise.all([
         inspectFile(join(homeDir, "MEMORY.md"), true, undefined, signal),
-        inspectFile(join(homeDir, "notes", "lessons.md"), true, undefined, signal),
+        inspectLessonsFile(homeDir, undefined, signal),
         inspectFile(join(runDir, "MEMORY.md"), true, cwdIsHome, signal),
-        inspectFile(join(runDir, "notes", "lessons.md"), true, cwdIsHome, signal),
+        inspectLessonsFile(runDir, cwdIsHome, signal),
         inspectFile(workLogPath, false, undefined, signal),
     ]);
     return {
@@ -108,8 +208,29 @@ export async function inspectMemoryPruneFiles(homeDir, runDir, workLogPath, sign
         work_log: workLog,
     };
 }
+export async function inspectMemoryPruneFiles(homeDir, runDir, workLogPath, signal) {
+    const [fixedFiles, notesManifest] = await Promise.all([
+        inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal),
+        inspectMemoryPruneNotes(homeDir, signal),
+    ]);
+    return { ...fixedFiles, notes_manifest: notesManifest };
+}
 export async function inspectMemoryPruneFilesWithinDeadline(homeDir, runDir, workLogPath, timeoutMs) {
-    return withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneFiles(homeDir, runDir, workLogPath, signal), timeoutMs);
+    const fixedFiles = await withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneFixedFiles(homeDir, runDir, workLogPath, signal), timeoutMs);
+    let notesManifest;
+    try {
+        notesManifest = await withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneNotes(homeDir, signal), timeoutMs);
+    }
+    catch (error) {
+        notesManifest = {
+            files: [],
+            total_count: 0,
+            omitted_count: 0,
+            truncated: false,
+            error: diagnosticError(error),
+        };
+    }
+    return { ...fixedFiles, notes_manifest: notesManifest };
 }
 export async function withinMemoryPruneDiagnosticsDeadline(operation, timeoutMs) {
     const controller = new AbortController();
@@ -145,6 +266,87 @@ 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 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 = [];
+    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 {
+        changes: allChanges.slice(0, MEMORY_PRUNE_NOTE_CHANGE_LIMIT),
+        change_count: allChanges.length,
+        truncated: allChanges.length > MEMORY_PRUNE_NOTE_CHANGE_LIMIT,
+        evidence_complete: before.error === undefined
+            && after.error === undefined
+            && !before.truncated
+            && !after.truncated
+            && 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) {
     const facts = {
         work_log_before_nonempty: before.work_log.exists && (before.work_log.size ?? 0) > 0,

package/dist/skills.js

@@ -6,6 +6,8 @@
  *  - claude: ~/.claude/skills
  * runtime 缺省(老 server 不下发)时按 claude 回落,与历史行为一致。
  * CREW_GLOBAL_SKILLS_DIR 若设置则覆盖以上全部,只扫它。
+ * Windows 上目录名相同,位于用户 profile 下(codex 官方说明:"On Windows, use the
+ * equivalent path under the user profile"),差异仅在分隔符,由 platform 选 path API。
  *
  * 每个 skill = 一个目录,内含 SKILL.md;从其 YAML frontmatter 取 name/description,
  * 缺失则回退到目录名。只读、容错(目录不存在/无 frontmatter 都不报错)。
@@ -15,19 +17,25 @@
  * 那两处是 reconciler 独占(每次整目录原子替换),且已由「项目技能」区单独展示。
  */
 import { readdir, readFile, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { join, posix, win32 } from "node:path";
 import { homedir } from "node:os";
 import { parseSkillFrontmatter } from "./skill-frontmatter.js";
-/** 该 runtime 的原生全局 skill 目录;顺序即优先级(重名时靠前的胜出)。 */
-function globalSkillsDirs(runtime) {
-    const override = process.env.CREW_GLOBAL_SKILLS_DIR;
+/**
+ * 该 runtime 的原生全局 skill 目录;顺序即优先级(重名时靠前的胜出)。
+ * 纯路径计算、不碰文件系统——所以能在任意宿主上跨平台单测。
+ */
+export function globalSkillsDirs(runtime, userHome = homedir(), platform = process.platform, env = process.env) {
+    const override = env.CREW_GLOBAL_SKILLS_DIR;
     if (override)
         return [override];
-    const home = homedir();
+    const pathApi = platform === "win32" ? win32 : posix;
     if (runtime === "codex") {
-        return [join(process.env.CODEX_HOME ?? join(home, ".codex"), "skills"), join(home, ".agents", "skills")];
+        return [
+            pathApi.join(env.CODEX_HOME ?? pathApi.join(userHome, ".codex"), "skills"),
+            pathApi.join(userHome, ".agents", "skills"),
+        ];
     }
-    return [join(home, ".claude", "skills")];
+    return [pathApi.join(userHome, ".claude", "skills")];
 }
 async function readSkillsFrom(dir) {
     const names = await readdir(dir).catch(() => []);
@@ -35,6 +43,7 @@ async function readSkillsFrom(dir) {
     for (const name of names) {
         if (name.startsWith("."))
             continue;
+        // 读盘一律用宿主的 path:上面算出的目录已是目标平台形态,此处只在本机拼 SKILL.md
         const skillMd = join(dir, name, "SKILL.md");
         const s = await stat(skillMd).catch(() => null);
         if (!s || !s.isFile())
@@ -46,8 +55,9 @@ async function readSkillsFrom(dir) {
     return skills;
 }
 /** 列出该 runtime 的全局 skill,按 name 去重后排序。 */
-export async function listSkills(runtime) {
-    const perDir = await Promise.all(globalSkillsDirs(runtime).map((dir) => readSkillsFrom(dir)));
+export async function listSkills(runtime, userHome = homedir(), platform = process.platform, env = process.env) {
+    const dirs = globalSkillsDirs(runtime, userHome, platform, env);
+    const perDir = await Promise.all(dirs.map((dir) => readSkillsFrom(dir)));
     // 同名 skill 可能同时存在于多个 root(如 ~/.codex/skills 与 ~/.agents/skills),
     // 取先命中的:既符合 runtime 的目录优先级,也避免前端 key 冲突。
     const byName = new Map();

package/package.json

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