@nowcrew/daemon 0.6.8 → 0.6.10

package/README.md

@@ -378,7 +378,7 @@ CREW_EXECUTION_MAX_QUEUED_TOTAL=128
 CREW_EXECUTION_MAX_STARTING_TOTAL=1
 CREW_EXECUTION_MAX_STARTING_PER_RUNTIME=1
 CREW_EXECUTION_START_GAP_MS=3000
-CREW_EXECUTION_STARTUP_TIMEOUT_MS=60000
+CREW_EXECUTION_STARTUP_TIMEOUT_MS=120000
 ```
 
 `MAX_PARALLEL_TOTAL` is the machine-wide process cap shared by protocol-v1 and legacy work.

package/dist/codex-startup-stage.js

@@ -0,0 +1,54 @@
+const STAGE_LINE_PREFIX_CAP = 512;
+const STAGE_PATTERN = /^\[codex-app-server\] stage=(spawn|initialize|thread_start|thread_resume|model_init) status=(start|ok|error|timeout) attempt=(\d+) elapsed_ms=(\d+)(?:\s|$)/;
+function parseBoundedStageLine(line) {
+    const match = STAGE_PATTERN.exec(line);
+    if (match === null)
+        return null;
+    const [, rawStage, status, rawAttempt, rawStageMs] = match;
+    const attempt = Number(rawAttempt);
+    const stageMs = Number(rawStageMs);
+    if (!Number.isSafeInteger(attempt) || attempt < 1
+        || !Number.isSafeInteger(stageMs) || stageMs < 0)
+        return null;
+    if (rawStage === "thread_resume") {
+        return { stage: "thread_start", status: status, attempt, stageMs, resumed: true };
+    }
+    return {
+        stage: rawStage,
+        status: status,
+        attempt,
+        stageMs,
+        ...(rawStage === "thread_start" ? { resumed: false } : {}),
+    };
+}
+export class CodexStartupStageParser {
+    onStage;
+    pendingPrefix = "";
+    constructor(onStage) {
+        this.onStage = onStage;
+    }
+    push(chunk) {
+        let remaining = chunk;
+        while (remaining.length > 0) {
+            const newline = remaining.indexOf("\n");
+            const segment = newline < 0 ? remaining : remaining.slice(0, newline);
+            const available = STAGE_LINE_PREFIX_CAP - this.pendingPrefix.length;
+            if (available > 0)
+                this.pendingPrefix += segment.slice(0, available);
+            if (newline < 0)
+                return;
+            this.emitPending();
+            remaining = remaining.slice(newline + 1);
+        }
+    }
+    finish() {
+        if (this.pendingPrefix.length > 0)
+            this.emitPending();
+    }
+    emitPending() {
+        const stage = parseBoundedStageLine(this.pendingPrefix.replace(/\r$/, ""));
+        this.pendingPrefix = "";
+        if (stage !== null)
+            this.onStage(stage);
+    }
+}

package/dist/config.js

@@ -17,7 +17,7 @@ export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
     maxStartingTotal: 1,
     maxStartingPerRuntime: 1,
     startupGapMs: 3_000,
-    startupTimeoutMs: 60_000,
+    startupTimeoutMs: 120_000,
 });
 // Fits the largest mandatory v1 lifecycle envelope (UUID + timestamps + outcome facts) with margin.
 export const MIN_EXECUTION_EVENT_BYTES = 512;

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,11 +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";
-function memoryPruneSnapshotFields(snapshot) {
+import { CodexStartupStageParser } from "./codex-startup-stage.js";
+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;
@@ -35,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", "长期记忆收尾诊断失败", {
@@ -615,10 +620,30 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 callbacks.onConsole?.(chunk);
         });
         let stderrTail = "";
+        const codexStartupStageState = { last: null };
+        const codexStartupStageParser = runtime.name === "codex"
+            ? new CodexStartupStageParser((stage) => {
+                codexStartupStageState.last = stage;
+                dslog("runtime.start_stage", "Codex runtime 启动阶段更新", {
+                    level: stage.status === "error" || stage.status === "timeout" ? "ERROR" : "INFO",
+                    execution_id: input.executionId,
+                    runtime: runtime.name,
+                    stage: stage.stage,
+                    status: stage.status,
+                    attempt: stage.attempt,
+                    stage_ms: stage.stageMs,
+                    startup_ms: Date.now() - runtimeLaunchAt,
+                    ...(stage.stage === "thread_start" ? { resumed: stage.resumed } : {}),
+                });
+            })
+            : null;
         child.stderr.on("data", (data) => {
             process.stderr.write(data);
-            stderrTail = (stderrTail + String(data)).slice(-STDERR_TAIL_CAP);
+            const text = String(data);
+            stderrTail = (stderrTail + text).slice(-STDERR_TAIL_CAP);
+            codexStartupStageParser?.push(text);
         });
+        child.stderr.on("end", () => codexStartupStageParser?.finish());
         let runtimeExit;
         try {
             if (startupReservation !== null) {
@@ -629,7 +654,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                         runtimeReadySignal.then(() => ({ kind: "ready" })),
                         child.exit.then((exit) => ({ kind: "exit", exit })),
                         new Promise((resolve) => {
-                            startupTimer = setTimeout(() => resolve({ kind: "timeout" }), dependencies.startupTimeoutMs ?? 60_000);
+                            startupTimer = setTimeout(() => resolve({ kind: "timeout" }), dependencies.startupTimeoutMs ?? 120_000);
                         }),
                     ]), dependencies.cancellation);
                 }
@@ -639,11 +664,18 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 }
                 if (startupOutcome.kind !== "ready") {
                     if (startupOutcome.kind === "timeout") {
+                        const lastCodexStartupStage = codexStartupStageState.last;
                         dslog("runtime.start_timeout", "runtime 启动超时", {
                             level: "ERROR",
                             execution_id: input.executionId,
                             runtime: runtime.name,
-                            startup_timeout_ms: dependencies.startupTimeoutMs ?? 60_000,
+                            startup_timeout_ms: dependencies.startupTimeoutMs ?? 120_000,
+                            ...(lastCodexStartupStage === null ? {} : {
+                                last_stage: lastCodexStartupStage.stage,
+                                last_stage_status: lastCodexStartupStage.status,
+                                last_stage_ms: lastCodexStartupStage.stageMs,
+                                attempt: lastCodexStartupStage.attempt,
+                            }),
                         });
                         await child.cancel?.();
                     }
@@ -744,6 +776,20 @@ 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,
+                        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,61 @@ function fileChanged(before, after) {
     }
     return before.size !== after.size || before.mtime_ms !== after.mtime_ms;
 }
+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 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 }),
+            });
+        }
+    }
+    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.files, ...after.files].every((file) => file.exists
+                && file.sha256 !== undefined
+                && file.error === undefined
+                && file.hash_skipped_reason === undefined),
+    };
+}
 export function evaluateMemoryPrunePostcondition(before, after, execution) {
     const facts = {
         work_log_before_nonempty: before.work_log.exists && (before.work_log.size ?? 0) > 0,

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

@@ -468,7 +468,7 @@ async function runCodexAppServerAttempt(bin, input, attempt, initializeTimeoutMs
             completionReject(new Error("Codex produced no semantic progress within the startup window"));
             void cancel();
         });
-        activeStage = "turn_start";
+        activeStage = "model_init";
         stageStartedAt = Date.now();
         const started = await rpc.request("turn/start", {
             threadId,

package/dist/serve.js

@@ -741,7 +741,7 @@ export function serve(config, opts = {}) {
                 try {
                     const data2 = req.type === "fs:list" ? await listWorkspace(root, req.path)
                         : req.type === "fs:read" ? await readWorkspaceFile(root, req.path)
-                            : req.type === "skills:list" ? await listSkills(config.agentsRoot, req.handle)
+                            : req.type === "skills:list" ? await listSkills(req.runtime)
                                 : { models: await listRuntimeModels(req.type === "probe-models" ? (req.runtime ?? "") : "") };
                     reply({ ok: true, data: data2 });
                 }

package/dist/skills.js

@@ -1,39 +1,70 @@
 /**
- * 枚举某 agent 可用的 skill,供 Profile 的 SKILLS 区展示。两个来源:
- *  - workspace 私有:<agentsRoot>/<handle>/skills/<name>/SKILL.md
- *  - 全局共享:    ~/.claude/skills/<name>/SKILL.md (可经 CREW_GLOBAL_SKILLS_DIR 覆盖)
+ * 枚举某 agent 可用的全局 skill,供 Profile 的 SKILLS 区展示。
+ *
+ * 目录由 runtime 决定——各 runtime 的原生发现路径互不相同:
+ *  - codex:  $CODEX_HOME/skills (未设时 ~/.codex/skills) + ~/.agents/skills
+ *  - 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 都不报错)。
+ *
+ * 不扫 agent 工作区:项目技能由 project-skills/reconciler 投影到
+ * <agentRoot>/.agents/skills 与 <agentRoot>/.crew/claude-skills/.claude/skills,
+ * 那两处是 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";
-const globalSkillsDir = () => process.env.CREW_GLOBAL_SKILLS_DIR ?? join(homedir(), ".claude", "skills");
-async function readSkillsFrom(dir, scope) {
+/**
+ * 该 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 pathApi = platform === "win32" ? win32 : posix;
+    if (runtime === "codex") {
+        return [
+            pathApi.join(env.CODEX_HOME ?? pathApi.join(userHome, ".codex"), "skills"),
+            pathApi.join(userHome, ".agents", "skills"),
+        ];
+    }
+    return [pathApi.join(userHome, ".claude", "skills")];
+}
+async function readSkillsFrom(dir) {
     const names = await readdir(dir).catch(() => []);
     const skills = [];
     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())
             continue;
         const md = await readFile(skillMd, "utf8").catch(() => "");
         const fm = parseSkillFrontmatter(md);
-        skills.push({ scope, name: fm.name || name, description: fm.description ?? "" });
+        skills.push({ scope: "global", name: fm.name || name, description: fm.description ?? "" });
     }
     return skills;
 }
-/** 列出 agent 的 workspace 私有 + 全局 skill,按 name 排序。 */
-export async function listSkills(agentsRoot, handle) {
-    const [ws, global] = await Promise.all([
-        readSkillsFrom(join(agentsRoot, handle, "skills"), "workspace"),
-        readSkillsFrom(globalSkillsDir(), "global"),
-    ]);
-    const all = [...ws, ...global];
-    all.sort((a, b) => (a.scope !== b.scope ? (a.scope === "workspace" ? -1 : 1) : a.name.localeCompare(b.name)));
-    return all;
+/** 列出该 runtime 的全局 skill,按 name 去重后排序。 */
+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();
+    for (const skills of perDir) {
+        for (const skill of skills)
+            if (!byName.has(skill.name))
+                byName.set(skill.name, skill);
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nowcrew/daemon",
-  "version": "0.6.8",
+  "version": "0.6.10",
   "type": "module",
   "description": "crew daemon — 运行在用户机器:拉起/管理 agent 进程,注入 crew CLI,归一化 runtime 事件",
   "license": "Apache-2.0",
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.2.1",
-    "@nowcrew/cli": "^0.4.13",
+    "@nowcrew/cli": "^0.4.14",
     "cross-spawn": "^7.0.6",
     "ws": "^8",
     "yaml": "^2.8.1",