@nowcrew/daemon 0.5.40 → 0.5.42

package/README.md

@@ -105,8 +105,10 @@ CREW_DAEMON_HOME="$HOME/.crew/daemon-dev" crew-daemon doctor --profile dev
 CREW_DAEMON_HOME="$HOME/.crew/daemon-dev" crew-daemon status --profile dev
 ```
 
-If the descriptor has drifted, the profile is stopped, or another host descriptor is not registered, the
-daemon fails closed and remains manually upgradeable.
+If the target descriptor has drifted or the profile is stopped, the daemon fails closed and remains
+manually upgradeable. On macOS, another unregistered legacy LaunchAgent may coexist only when its plist
+exactly matches a generated NowCrew service and resolves to a different npm prefix. An unverifiable or
+same-prefix descriptor still fails closed.
 
 The daemon advertises `daemon_update_v1` only when all of these conditions hold:
 
@@ -115,7 +117,7 @@ The daemon advertises `daemon_update_v1` only when all of these conditions hold:
 | Platform | macOS LaunchAgent or Linux systemd user service |
 | Entrypoint | global `@nowcrew/daemon/dist/main.js`, not npx or source/tsx |
 | Startup | `crew-daemon serve --profile <name>` through the installed service |
-| Registry | every other NowCrew descriptor on the OS user account is registered and conflict-free; the exact target legacy descriptor may be adopted once |
+| Registry | registered descriptors remain conflict-free; the exact target legacy descriptor may be adopted once; an exact macOS legacy descriptor on another npm prefix may coexist |
 | Identity | service ID, descriptor, daemon home, Agent root, entrypoint, package root, and npm prefix match |
 | Service | the selected profile is running and holds the installation lease |
 | Install root | a standard writable Unix global npm prefix can be derived from the running entrypoint |

package/dist/daemon-update-eligibility.js

@@ -6,6 +6,7 @@ import { builtDaemonEntry } from "./computer-cli.js";
 import { buildServiceSpec, readServiceDescriptor, serviceStatus, } from "./computer-service.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { daemonInstallationLeaseHeld } from "./daemon-installation-lease.js";
+import { inspectLegacyServiceInstallation } from "./legacy-service-installation.js";
 import { assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, managedServiceIdentityMatches, readManagedServiceRegistry, serviceDescriptorSha256, } from "./managed-service-registry.js";
 function defaults() {
     return {
@@ -22,8 +23,25 @@ function defaults() {
         serviceStatus,
         assertWritable: (path) => access(path, constants.W_OK),
         installationLeaseHeld: daemonInstallationLeaseHeld,
+        inspectLegacyDescriptorInstallation: (descriptorPath) => inspectLegacyServiceInstallation(descriptorPath, process.platform, homedir(), process.getuid?.()),
     };
 }
+async function registryCoversUpdateScope(services, descriptorPaths, targetDescriptorPath, npmPrefix, inspectLegacyDescriptorInstallation) {
+    for (const descriptorPath of descriptorPaths) {
+        if (descriptorPath === targetDescriptorPath)
+            continue;
+        try {
+            assertRegistryCoversDescriptors(services, [descriptorPath]);
+            continue;
+        }
+        catch {
+            const legacy = await inspectLegacyDescriptorInstallation(descriptorPath).catch(() => null);
+            if (legacy === null || legacy.npmPrefix === npmPrefix)
+                return false;
+        }
+    }
+    return true;
+}
 export async function detectDaemonUpdateEligibility(profileName, overrides = {}) {
     const deps = { ...defaults(), ...overrides };
     if (deps.platform !== "darwin" && deps.platform !== "linux") {
@@ -65,10 +83,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
     const registered = services.find((record) => record.serviceId === spec.id
         || (record.daemonHome === deps.profileHome && record.profile === profileName));
     if (registered !== undefined) {
-        try {
-            assertRegistryCoversDescriptors(services, await deps.listManagedDescriptorPaths());
-        }
-        catch {
+        if (!await registryCoversUpdateScope(services, await deps.listManagedDescriptorPaths(), spec.descriptorPath, installation.npmPrefix, deps.inspectLegacyDescriptorInstallation)) {
             return { eligible: false, reason: "managed_service_registry_incomplete" };
         }
         const descriptor = await deps.readServiceDescriptor(spec).catch(() => null);
@@ -109,12 +124,7 @@ export async function detectDaemonUpdateEligibility(profileName, overrides = {})
         if (legacyDescriptor !== legacySpec.descriptor) {
             return { eligible: false, reason: "managed_service_not_registered" };
         }
-        try {
-            const descriptorPaths = await deps.listManagedDescriptorPaths();
-            const targetPath = legacySpec.descriptorPath;
-            assertRegistryCoversDescriptors(services, descriptorPaths.filter((descriptorPath) => descriptorPath !== targetPath));
-        }
-        catch {
+        if (!await registryCoversUpdateScope(services, await deps.listManagedDescriptorPaths(), legacySpec.descriptorPath, installation.npmPrefix, deps.inspectLegacyDescriptorInstallation)) {
             return { eligible: false, reason: "managed_service_registry_incomplete" };
         }
         status = await deps.serviceStatus(legacySpec);

package/dist/legacy-service-installation.js

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+import { buildServiceSpec, systemCommandRunner, } from "./computer-service.js";
+import { daemonGlobalInstallation } from "./daemon-installation.js";
+const LegacyLaunchAgentSchema = z.object({
+    Label: z.string().min(1),
+    ProgramArguments: z.tuple([
+        z.string().refine(isAbsolute),
+        z.string().refine(isAbsolute),
+        z.literal("serve"),
+        z.literal("--profile"),
+        z.string().regex(/^[a-z0-9][a-z0-9_-]{0,47}$/),
+        z.literal("--daemon-home"),
+        z.string().refine(isAbsolute),
+    ]),
+    KeepAlive: z.literal(true),
+    ProcessType: z.literal("Background"),
+}).strict();
+export async function inspectLegacyServiceInstallation(descriptorPath, platform, userHome = homedir(), uid = process.getuid?.(), runner = systemCommandRunner) {
+    if (platform !== "darwin" || uid === undefined)
+        return null;
+    const result = await runner("/usr/bin/plutil", ["-convert", "json", "-o", "-", descriptorPath]);
+    if (result.exitCode !== 0)
+        return null;
+    let decoded;
+    try {
+        decoded = JSON.parse(result.stdout);
+    }
+    catch {
+        return null;
+    }
+    const parsed = LegacyLaunchAgentSchema.safeParse(decoded);
+    if (!parsed.success)
+        return null;
+    const [nodePath, entryPath, , , profile, , profileHome] = parsed.data.ProgramArguments;
+    const installation = daemonGlobalInstallation(entryPath, platform);
+    if (installation === null)
+        return null;
+    const spec = buildServiceSpec({
+        platform,
+        profile,
+        userHome,
+        uid,
+        nodePath,
+        entryPath,
+        profileHome,
+        legacyServiceId: true,
+    });
+    if (spec.id !== parsed.data.Label || spec.descriptorPath !== descriptorPath)
+        return null;
+    if (await readFile(descriptorPath, "utf8").catch(() => null) !== spec.descriptor)
+        return null;
+    return { npmPrefix: installation.npmPrefix };
+}

package/dist/local-executor.js

@@ -1,7 +1,7 @@
 import { createInterface } from "node:readline";
-import { rm, writeFile } from "node:fs/promises";
+import { readFile, rm, writeFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
-import { prepareWorkspace, rotateAgentSession, } from "./workspace.js";
+import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
 import { spawnClaude } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
 import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepSeekCodexHome, } from "./runtimes/codex-deepseek-config.js";
@@ -18,7 +18,7 @@ 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 { inspectMemoryPruneFiles, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
+import { evaluateMemoryPrunePostcondition, inspectMemoryPruneFilesWithinDeadline, parseMemoryPruneTraceId, } from "./memory-prune-diagnostics.js";
 function memoryPruneSnapshotFields(snapshot) {
     const fields = {};
     for (const [label, fact] of Object.entries(snapshot)) {
@@ -28,9 +28,25 @@ function memoryPruneSnapshotFields(snapshot) {
         fields[`${label}_sha256`] = fact.sha256;
         fields[`${label}_hash_skipped_reason`] = fact.hash_skipped_reason;
         fields[`${label}_error`] = fact.error;
+        fields[`${label}_markdown_heading_count`] = fact.markdown_heading_count;
+        fields[`${label}_lessons_reference_count`] = fact.lessons_reference_count;
+        fields[`${label}_same_as_shared_path`] = fact.same_as_shared_path;
     }
     return fields;
 }
+function logMemoryPruneDiagnosticsFailure(input, traceId, phase, error) {
+    const errorCode = error?.code;
+    dslog("memory_prune.diagnostics_failed", "长期记忆收尾诊断失败", {
+        level: "WARN",
+        execution_id: input.executionId,
+        agent_handle: input.handle,
+        task_key: input.taskKey,
+        prune_trace_id: traceId,
+        diagnostics_phase: phase,
+        error_name: error instanceof Error ? error.name : "unknown",
+        error_code: errorCode,
+    });
+}
 function truncateUtf8(value, maxBytes) {
     if (maxBytes <= 0)
         return "";
@@ -62,6 +78,7 @@ export function withLocalExecutionFacts(serverPrompt, maxBytes) {
     };
 }
 const STDERR_TAIL_CAP = 2_000;
+const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -158,6 +175,7 @@ function resolvePrompt(prompt, context) {
     return typeof prompt === "string" ? prompt : prompt(context);
 }
 const nativeSessionLeaseTails = new Map();
+const activeMemoryPrunes = new Map();
 async function withKeyedLease(key, operation, cancellation) {
     const predecessor = nativeSessionLeaseTails.get(key) ?? Promise.resolve();
     let release;
@@ -221,6 +239,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneRuntimeExitCode;
     let memoryPruneExecutorCompleted = false;
     let memoryPruneFailurePhase = "diagnostics_before";
+    let memoryPruneBeforeSnapshot = null;
+    let memoryPruneSharedWriteKey = null;
+    let executionWorkspace = workspace;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
             throw new Error("DeepSeek API key is not configured for this Agent");
@@ -230,24 +251,62 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }
         const supportsNativeResume = runtime.name === "claude"
             || (dependencies.launchRuntime !== undefined && runtimeCapability(runtime.name).nativeResume);
-        const prior = input.session.enabled && supportsNativeResume
+        const currentPrior = input.session.enabled && supportsNativeResume
             ? await readSession(workspace.sessionDir)
             : null;
-        const resumeSessionId = supportsNativeResume && workspace.sessionResume
-            ? pickResumeId(prior, Date.now(), input.session.warmMs, currentModel, input.session.budgetTokens, input.session.maxTurns, providerFp)
+        // Interactive V1 uses collision-resistant session directories, while the
+        // older legacy path stored metadata under tasks/<safe thread key>. Import
+        // that metadata once so an existing thread can cross the protocol boundary
+        // without losing its native runtime conversation.
+        const legacyRunDir = input.session.enabled
+            && supportsNativeResume
+            && input.keyMode === "opaque"
+            && input.resumeKey !== undefined
+            ? join(input.launch.agentsRoot, input.handle, "tasks", safeKey(input.resumeKey))
+            : null;
+        const legacyCwdMarker = legacyRunDir === null
+            ? null
+            : join(workspace.sessionDir, ".legacy-runtime-cwd");
+        const legacyCwdPinned = legacyCwdMarker !== null
+            && await readFile(legacyCwdMarker, "utf8").then((value) => value === "1").catch(() => false);
+        const legacyPrior = legacyRunDir === null || (currentPrior !== null && !legacyCwdPinned)
+            ? null
+            : await readSession(legacyRunDir);
+        const prior = currentPrior ?? legacyPrior;
+        const sessionExists = workspace.sessionResume || legacyPrior !== null;
+        const usesLegacyCwd = legacyRunDir !== null
+            && (legacyCwdPinned || (currentPrior === null && legacyPrior !== null));
+        executionWorkspace = !usesLegacyCwd || legacyRunDir === null
+            ? workspace
+            : {
+                ...workspace,
+                runDir: legacyRunDir,
+                workLogPath: join(legacyRunDir, "work-log.md"),
+                workLog: await readFile(join(legacyRunDir, "work-log.md"), "utf8").catch(() => ""),
+            };
+        // Claude Code accepts --resume and --model together. Compare against the
+        // prior model only when this turn has an explicit model, so the remaining
+        // safety checks can still decide whether the same session is reusable.
+        // An omitted model stays model-sensitive because it cannot reliably switch
+        // a resumed session back to the runtime default.
+        const resumeComparisonModel = runtime.name === "claude" && currentModel !== null
+            ? prior?.model ?? currentModel
+            : currentModel;
+        const resumeSessionId = supportsNativeResume && sessionExists
+            ? pickResumeId(prior, Date.now(), input.session.warmMs, resumeComparisonModel, input.session.budgetTokens, input.session.maxTurns, providerFp)
             : null;
         const resuming = resumeSessionId !== null;
-        const rotatedForBudget = !resuming && supportsNativeResume && workspace.sessionResume
-            && pickResumeId(prior, Date.now(), input.session.warmMs, currentModel, 0, 0, providerFp) !== null;
+        const rotatedForBudget = !resuming && supportsNativeResume && sessionExists
+            && pickResumeId(prior, Date.now(), input.session.warmMs, resumeComparisonModel, 0, 0, providerFp) !== null;
         const nearBudget = resuming && isNearBudget(prior, input.session.softTokens);
-        const rotated = Boolean(workspace.agentSessionId && workspace.sessionResume && !resuming);
+        const rotated = Boolean(workspace.agentSessionId && sessionExists && !resuming);
         // Codex and Kimi choose their own id on a fresh start, so the native id persisted in
         // .crew-session.json can differ from the bootstrap id in .session. Resume the former.
         const launchSessionId = resumeSessionId ?? (rotated
             ? await rotateAgentSession(workspace.sessionDir)
             : workspace.agentSessionId);
         const promptContext = {
-            workspace,
+            workspace: executionWorkspace,
             resuming,
             rotatedForBudget,
             nearBudget,
@@ -256,12 +315,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         if (input.attachments && input.attachments.length > 0) {
             if (dependencies.cancellation?.isRequested())
                 throw new RuntimeCancelledError();
-            knownAttachmentDirectory = executionAttachmentDirectory(workspace.runDir, input.executionId);
+            knownAttachmentDirectory = executionAttachmentDirectory(executionWorkspace.runDir, input.executionId);
             const controller = new AbortController();
             const materialization = Promise.resolve().then(() => (dependencies.materializeAttachments ?? materializeAttachments)({
                 serverUrl: input.launch.serverUrl,
                 token: input.launch.token,
-                runDir: workspace.runDir,
+                runDir: executionWorkspace.runDir,
                 executionId: input.executionId,
                 attachments: input.attachments,
                 signal: controller.signal,
@@ -287,14 +346,36 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         memoryPruneTraceId = parseMemoryPruneTraceId(wakePrompt);
         if (memoryPruneTraceId !== null) {
-            const snapshot = await inspectMemoryPruneFiles(workspace.dir, workspace.workLogPath);
-            dslog("memory_prune.files_before", "长期记忆收尾执行前文件指纹", {
+            memoryPruneSharedWriteKey = JSON.stringify([input.launch.agentsRoot, input.handle]);
+            const activePruneCount = (activeMemoryPrunes.get(memoryPruneSharedWriteKey) ?? 0) + 1;
+            activeMemoryPrunes.set(memoryPruneSharedWriteKey, activePruneCount);
+            dslog(activePruneCount > 1
+                ? "memory_prune.shared_write_overlap_detected"
+                : "memory_prune.shared_write_started", activePruneCount > 1
+                ? "同一 Agent 存在重叠的共享记忆收尾"
+                : "Agent 共享记忆收尾已开始", {
+                ...(activePruneCount > 1 ? { level: "WARN" } : {}),
                 execution_id: input.executionId,
                 agent_handle: input.handle,
                 task_key: input.taskKey,
                 prune_trace_id: memoryPruneTraceId,
-                ...memoryPruneSnapshotFields(snapshot),
+                active_prune_count: activePruneCount,
             });
+            try {
+                const snapshot = await inspectMemoryPruneFilesWithinDeadline(executionWorkspace.dir, executionWorkspace.runDir, executionWorkspace.workLogPath, dependencies.memoryPruneDiagnosticsTimeoutMs
+                    ?? MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS);
+                memoryPruneBeforeSnapshot = snapshot;
+                dslog("memory_prune.files_before", "长期记忆收尾执行前文件指纹", {
+                    execution_id: input.executionId,
+                    agent_handle: input.handle,
+                    task_key: input.taskKey,
+                    prune_trace_id: memoryPruneTraceId,
+                    ...memoryPruneSnapshotFields(snapshot),
+                });
+            }
+            catch (error) {
+                logMemoryPruneDiagnosticsFailure(input, memoryPruneTraceId, "before", error);
+            }
         }
         memoryPruneFailurePhase = "prompt_write";
         await awaitWithCancellation(writeFile(workspace.systemPromptPath, systemPrompt, "utf8"), dependencies.cancellation);
@@ -313,7 +394,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             CREW_TOKEN: input.launch.token,
             CREW_CHANNEL: input.channelId,
             CREW_HOME: workspace.dir,
-            CREW_TASK_LOG: workspace.workLogPath,
+            CREW_TASK_LOG: executionWorkspace.workLogPath,
             ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
             XDG_CONFIG_HOME: join(workspace.homeDir, ".config"),
             XDG_DATA_HOME: join(workspace.homeDir, ".local", "share"),
@@ -355,7 +436,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const launchRequest = {
             runtime: runtime.name,
             bin: runtime.name,
-            cwd: workspace.runDir,
+            cwd: executionWorkspace.runDir,
             ...(input.projectSkills === undefined ? {} : { agentRoot: workspace.dir }),
             systemPromptPath: workspace.systemPromptPath,
             systemPrompt,
@@ -516,10 +597,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 lastExitOk: exitCode === 0,
                 ...(contextTokens === undefined ? {} : { contextTokens }),
             });
+            if (exitCode === 0 && usesLegacyCwd && !legacyCwdPinned && legacyCwdMarker !== null) {
+                await writeFile(legacyCwdMarker, "1", "utf8");
+            }
         }
         memoryPruneExecutorCompleted = true;
         return {
-            workspaceRunDir: workspace.runDir,
+            workspaceRunDir: executionWorkspace.runDir,
             exitCode,
             ...(terminationSignal === undefined ? {} : { terminationSignal }),
             activities,
@@ -541,24 +625,60 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     finally {
         startupReservation?.release();
         if (memoryPruneTraceId !== null) {
-            const snapshot = await inspectMemoryPruneFiles(workspace.dir, workspace.workLogPath);
-            dslog("memory_prune.files_after", "长期记忆收尾执行后文件指纹", {
+            try {
+                const snapshot = await inspectMemoryPruneFilesWithinDeadline(executionWorkspace.dir, executionWorkspace.runDir, executionWorkspace.workLogPath, dependencies.memoryPruneDiagnosticsTimeoutMs
+                    ?? MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS);
+                dslog("memory_prune.files_after", "长期记忆收尾执行后文件指纹", {
+                    execution_id: input.executionId,
+                    agent_handle: input.handle,
+                    task_key: input.taskKey,
+                    prune_trace_id: memoryPruneTraceId,
+                    runtime_exit_code: memoryPruneRuntimeExitCode,
+                    executor_outcome: memoryPruneExecutorCompleted ? "succeeded" : "failed",
+                    ...memoryPruneSnapshotFields(snapshot),
+                });
+                if (memoryPruneBeforeSnapshot !== null) {
+                    const postcondition = evaluateMemoryPrunePostcondition(memoryPruneBeforeSnapshot, snapshot, {
+                        executorCompleted: memoryPruneExecutorCompleted,
+                        ...(memoryPruneRuntimeExitCode === undefined
+                            ? {}
+                            : { runtimeExitCode: memoryPruneRuntimeExitCode }),
+                    });
+                    dslog("memory_prune.postcondition_evaluated", "长期记忆收尾后置条件已评估", {
+                        execution_id: input.executionId,
+                        agent_handle: input.handle,
+                        task_key: input.taskKey,
+                        prune_trace_id: memoryPruneTraceId,
+                        postcondition_outcome: postcondition.outcome,
+                        ...Object.fromEntries(Object.entries(postcondition).filter(([key]) => key !== "outcome")),
+                    });
+                }
+            }
+            catch (error) {
+                logMemoryPruneDiagnosticsFailure(input, memoryPruneTraceId, "after", error);
+            }
+            dslog("memory_prune.execution_completed", "长期记忆收尾执行结束", {
                 execution_id: input.executionId,
                 agent_handle: input.handle,
                 task_key: input.taskKey,
                 prune_trace_id: memoryPruneTraceId,
-                runtime_exit_code: memoryPruneRuntimeExitCode,
                 executor_outcome: memoryPruneExecutorCompleted ? "succeeded" : "failed",
-                ...memoryPruneSnapshotFields(snapshot),
+                runtime_exit_code: memoryPruneRuntimeExitCode,
+                ...(memoryPruneExecutorCompleted ? {} : { failure_phase: memoryPruneFailurePhase }),
             });
-            dslog("memory_prune.execution_completed", "长期记忆收尾执行结束", {
+        }
+        if (memoryPruneSharedWriteKey !== null) {
+            const activePruneCount = Math.max(0, (activeMemoryPrunes.get(memoryPruneSharedWriteKey) ?? 1) - 1);
+            if (activePruneCount === 0)
+                activeMemoryPrunes.delete(memoryPruneSharedWriteKey);
+            else
+                activeMemoryPrunes.set(memoryPruneSharedWriteKey, activePruneCount);
+            dslog("memory_prune.shared_write_finished", "Agent 共享记忆收尾已结束", {
                 execution_id: input.executionId,
                 agent_handle: input.handle,
                 task_key: input.taskKey,
                 prune_trace_id: memoryPruneTraceId,
-                executor_outcome: memoryPruneExecutorCompleted ? "succeeded" : "failed",
-                runtime_exit_code: memoryPruneRuntimeExitCode,
-                ...(memoryPruneExecutorCompleted ? {} : { failure_phase: memoryPruneFailurePhase }),
+                active_prune_count: activePruneCount,
             });
         }
         const attachmentDirectories = new Set([

package/dist/memory-prune-diagnostics.js

@@ -2,23 +2,36 @@ import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { stat } 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 function parseMemoryPruneTraceId(wakePrompt) {
     return TRACE_PATTERN.exec(wakePrompt)?.[1] ?? null;
 }
-async function inspectFile(path) {
+async function inspectFile(path, markdownFacts = false, sameAsSharedPath, signal) {
     let metadata;
     try {
         metadata = await stat(path);
     }
     catch (error) {
         const code = error.code;
+        const pathFact = sameAsSharedPath === undefined
+            ? {}
+            : { same_as_shared_path: sameAsSharedPath };
         if (code === "ENOENT")
-            return { exists: false };
-        return { exists: false, error: code ?? (error instanceof Error ? error.name : "unknown") };
+            return { exists: false, ...pathFact };
+        return {
+            exists: false,
+            ...pathFact,
+            error: code ?? (error instanceof Error ? error.name : "unknown"),
+        };
     }
-    const fact = { exists: true, size: metadata.size, mtime_ms: metadata.mtimeMs };
+    const fact = {
+        exists: true,
+        size: metadata.size,
+        mtime_ms: metadata.mtimeMs,
+        ...(sameAsSharedPath === undefined ? {} : { same_as_shared_path: sameAsSharedPath }),
+    };
     if (!metadata.isFile())
         return { ...fact, hash_skipped_reason: "not_regular_file" };
     if (metadata.size > MEMORY_PRUNE_HASH_LIMIT_BYTES) {
@@ -27,7 +40,29 @@ async function inspectFile(path) {
     try {
         const hash = createHash("sha256");
         let bytesRead = 0;
-        const stream = createReadStream(path);
+        let markdownHeadingCount = 0;
+        let lessonsReferenceCount = 0;
+        let pendingText = "";
+        const decoder = new StringDecoder("utf8");
+        const inspectText = (text, final) => {
+            if (!markdownFacts)
+                return;
+            pendingText += text;
+            const lines = pendingText.split(/\r?\n/);
+            pendingText = final ? "" : (lines.pop() ?? "");
+            for (const line of lines) {
+                if (/^\s{0,3}#{1,6}(?:\s|$)/.test(line))
+                    markdownHeadingCount += 1;
+                lessonsReferenceCount += line.match(/notes\/lessons\.md/gi)?.length ?? 0;
+            }
+            if (final && pendingText !== "") {
+                if (/^\s{0,3}#{1,6}(?:\s|$)/.test(pendingText))
+                    markdownHeadingCount += 1;
+                lessonsReferenceCount += pendingText.match(/notes\/lessons\.md/gi)?.length ?? 0;
+                pendingText = "";
+            }
+        };
+        const stream = createReadStream(path, signal === undefined ? {} : { signal });
         try {
             for await (const chunk of stream) {
                 bytesRead += chunk.length;
@@ -35,23 +70,116 @@ async function inspectFile(path) {
                     return { ...fact, hash_skipped_reason: "grew_too_large" };
                 }
                 hash.update(chunk);
+                inspectText(decoder.write(chunk), false);
             }
+            inspectText(decoder.end(), true);
         }
         finally {
             stream.destroy();
         }
-        return { ...fact, sha256: hash.digest("hex") };
+        return {
+            ...fact,
+            sha256: hash.digest("hex"),
+            ...(markdownFacts ? {
+                markdown_heading_count: markdownHeadingCount,
+                lessons_reference_count: lessonsReferenceCount,
+            } : {}),
+        };
     }
     catch (error) {
         const code = error.code;
         return { ...fact, error: code ?? (error instanceof Error ? error.name : "unknown") };
     }
 }
-export async function inspectMemoryPruneFiles(homeDir, workLogPath) {
-    const [memory, lessons, workLog] = await Promise.all([
-        inspectFile(join(homeDir, "MEMORY.md")),
-        inspectFile(join(homeDir, "notes", "lessons.md")),
-        inspectFile(workLogPath),
+export async function inspectMemoryPruneFiles(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),
+        inspectFile(join(runDir, "MEMORY.md"), true, cwdIsHome, signal),
+        inspectFile(join(runDir, "notes", "lessons.md"), true, cwdIsHome, signal),
+        inspectFile(workLogPath, false, undefined, signal),
     ]);
-    return { memory, lessons, work_log: workLog };
+    return {
+        memory,
+        lessons,
+        cwd_memory: cwdMemory,
+        cwd_lessons: cwdLessons,
+        work_log: workLog,
+    };
+}
+export async function inspectMemoryPruneFilesWithinDeadline(homeDir, runDir, workLogPath, timeoutMs) {
+    return withinMemoryPruneDiagnosticsDeadline((signal) => inspectMemoryPruneFiles(homeDir, runDir, workLogPath, signal), timeoutMs);
+}
+export async function withinMemoryPruneDiagnosticsDeadline(operation, timeoutMs) {
+    const controller = new AbortController();
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            const error = Object.assign(new Error("Memory prune diagnostics timed out"), {
+                code: "diagnostics_timeout",
+            });
+            reject(error);
+            controller.abort(error);
+        }, timeoutMs);
+        timer.unref?.();
+    });
+    try {
+        return await Promise.race([
+            operation(controller.signal),
+            deadline,
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function fileChanged(before, after) {
+    if (before.exists !== after.exists)
+        return true;
+    if (!before.exists && !after.exists)
+        return false;
+    if (before.sha256 !== undefined && after.sha256 !== undefined) {
+        return before.sha256 !== after.sha256;
+    }
+    return before.size !== after.size || before.mtime_ms !== after.mtime_ms;
+}
+export function evaluateMemoryPrunePostcondition(before, after, execution) {
+    const facts = {
+        work_log_before_nonempty: before.work_log.exists && (before.work_log.size ?? 0) > 0,
+        work_log_cleared: !after.work_log.exists || after.work_log.size === 0,
+        lessons_changed: fileChanged(before.lessons, after.lessons),
+        shared_memory_changed: fileChanged(before.memory, after.memory),
+        shared_memory_has_lessons_reference: (after.memory.lessons_reference_count ?? 0) > 0,
+        cwd_memory_changed: !after.cwd_memory.same_as_shared_path
+            && fileChanged(before.cwd_memory, after.cwd_memory),
+        cwd_memory_has_lessons_reference: !after.cwd_memory.same_as_shared_path
+            && (after.cwd_memory.lessons_reference_count ?? 0) > 0,
+        cwd_lessons_changed: !after.cwd_lessons.same_as_shared_path
+            && fileChanged(before.cwd_lessons, after.cwd_lessons),
+    };
+    let outcome;
+    if (!execution.executorCompleted)
+        outcome = "executor_failed";
+    else if (execution.runtimeExitCode !== 0)
+        outcome = "runtime_failed";
+    else if (!before.work_log.exists)
+        outcome = "source_work_log_missing";
+    else if (!facts.work_log_before_nonempty)
+        outcome = "source_work_log_empty";
+    else if (!facts.work_log_cleared)
+        outcome = "work_log_not_cleared";
+    else if (facts.lessons_changed && facts.shared_memory_has_lessons_reference) {
+        outcome = "promoted_and_indexed";
+    }
+    else if ((!facts.shared_memory_changed && facts.cwd_memory_changed)
+        || (!facts.lessons_changed && facts.cwd_lessons_changed)) {
+        outcome = "possible_wrong_memory_path";
+    }
+    else if (facts.lessons_changed)
+        outcome = "promoted_without_index_change";
+    else
+        outcome = "no_files_changed";
+    return { outcome, ...facts };
 }

package/dist/prompt.js

@@ -18,7 +18,8 @@ const EXTERNAL_RESULT_READABILITY = `
 - 前三行依次说清结论、影响和需要谁做什么;不要用背景铺垫或复述任务开场。
 - 除非用户明确要求完整明细,正文最多三个短小节、最多六个要点;总结日志、命令输出和长表格,不要整段粘贴。
 - 有足够重点时,只加粗三到五处真正决定性的数字、最终状态、风险、截止时间、负责人或行动项;不足三处时宁缺毋滥。加粗范围要短,不要整段加粗,不要把每个数字都加粗,不得强化未经验证的判断。
-- 使用标题、列表、引用和加粗形成无颜色也清楚的层级;不得输出 \`<font>\` 或其它未确认可用于企微流式消息的 HTML 标色标签。`;
+- 需要颜色层级时,只在确有对应语义的短加粗重点前使用一个彩色圆点:🟢 绿色圆点表示已验证成功或健康,🟠 橙色圆点表示风险、临期或需要关注,🔴 红色圆点表示失败、阻塞或严重异常,🔵 蓝色圆点表示负责人、行动项或关键中性数据。每个短加粗重点前最多放一个;不要给普通段落、标题或每个要点都加标记。
+- 使用标题、列表、引用、彩色圆点和加粗形成在企微原生流式消息中稳定可见的层级;不得输出 \`<font>\` 或其它 HTML 标色标签。`;
 export function capWorkLogForInject(workLog, cap = WORKLOG_INJECT_CAP) {
     if (workLog.length <= cap)
         return workLog;

package/package.json

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