@nowcrew/daemon 0.6.68 → 0.6.69

package/dist/local-executor.js

@@ -1,7 +1,6 @@
 import { createInterface } from "node:readline";
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { delimiter, join } from "node:path";
-import { cleanupSelfTrainingRunDir } from "./self-training-workspace.js";
 import { prepareWorkspace, rotateAgentSession, safeKey, } from "./workspace.js";
 import { CLAUDE_ADDITIONAL_DIRECTORY_INSTRUCTIONS_ENV, isClaudeAdditionalDirectoryInstructionsSupported, probeClaudeVersion, spawnClaude, } from "./runtimes/claude.js";
 import { spawnCodex } from "./runtimes/codex.js";
@@ -9,7 +8,7 @@ import { DEEPSEEK_CODEX_MODEL, DEEPSEEK_CODEX_REASONING_LEVELS, materializeDeepS
 import { materializeDefaultCodexHome } from "./runtimes/codex-home.js";
 import { materializePrivateCodexHome } from "./codex-home-launch.js";
 import { spawnKimi, KIMI_EFFORT_LEVELS } from "./runtimes/kimi.js";
-import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, sanitizeEnvVars, } from "./provider-env.js";
+import { applyDeepSeekHarnessMachineEnv, applyProviderEnv, providerFingerprint, } from "./provider-env.js";
 import { augmentedPath } from "./runtime-path.js";
 import { extractFinalText, extractRunMeta, normalizeEvent, parseLine, } from "./normalize.js";
 import { readSession, writeSession, pickResumeId, isNearBudget } from "./session.js";
@@ -32,6 +31,7 @@ import { diffMemoryPruneNotes, evaluateMemoryPrunePostcondition, inspectMemoryPr
 import { createLocalMemoryTelemetry, logLocalMemoryContextPrepareFailure, logLocalMemoryDiagnosticsFailure, } from "./local-memory-telemetry.js";
 import { CodexStartupStageParser } from "./codex-startup-stage.js";
 import { formatRuntimeStartupError } from "./runtime-startup-error.js";
+import { commitLocalMemoryResultAfterExit, initializeLocalMemoryV2ForWorkspace, isLocalMemoryV2Eligible, localMemoryResultPath as makeLocalMemoryResultPath, renderLocalMemoryResultInstructions, } from "./local-memory/runtime.js";
 function memoryPruneFileFactFields(fileFacts) {
     const fields = {};
     for (const [label, fact] of Object.entries(fileFacts)) {
@@ -78,6 +78,7 @@ const RUNTIME_RUNNING_CALLBACK_TIMEOUT_MS = 30_000;
 const MEMORY_PRUNE_DIAGNOSTICS_TIMEOUT_MS = 2_000;
 const LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS = 250;
 const CLAUDE_INSTRUCTION_WARNING = "claude_additional_directory_instructions_unverified";
+const CODEX_COLLABORATION_EXEC_WARNING = "codex_collaboration_disabled_on_exec";
 const ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const RESERVED_ENV = new Set([
     "PATH",
@@ -97,6 +98,14 @@ function withoutClaudeInstructionFlag(env) {
 const warnRuntimeLocally = (code) => {
     process.stderr.write(`[runtime-warning] ${code}\n`);
 };
+export function sanitizeEnvVars(raw) {
+    if (!raw)
+        return {};
+    return Object.fromEntries(Object.entries(raw).filter(([key, value]) => typeof value === "string"
+        && ENV_KEY_RE.test(key)
+        && !key.toUpperCase().startsWith("CREW_")
+        && !RESERVED_ENV.has(key.toUpperCase())));
+}
 export function awaitExit(child) {
     return new Promise((resolve) => {
         let settled = false;
@@ -147,7 +156,6 @@ async function launchLegacyRuntime(request) {
         effectivePermission: request.effectivePermission,
         ...(request.model === undefined ? {} : { model: request.model }),
         ...(request.reasoning === undefined ? {} : { reasoning: request.reasoning }),
-        ...(request.networkAccess === undefined ? {} : { networkAccess: request.networkAccess }),
     };
     if (request.runtime === "claude") {
         const additionalDirectories = request.claudeAdditionalDirectories
@@ -237,7 +245,6 @@ export async function executeLocal(input, callbacks = {}, dependencies = {}) {
 async function executeLocalUnlocked(input, callbacks, dependencies) {
     const providerConfig = input.launch.providerConfig ?? {};
     const { runtime } = input;
-    const isolatedMaintenance = input.maintenancePurpose === "self_training";
     const isDeepSeekCodex = runtime.name === "codex" && providerConfig.provider === "deepseek";
     const currentModel = isDeepSeekCodex ? DEEPSEEK_CODEX_MODEL : runtime.model ?? null;
     const launchModel = isDeepSeekCodex ? DEEPSEEK_CODEX_MODEL : runtime.model;
@@ -262,7 +269,6 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ? {}
                 : { sessionContextFingerprint: input.sessionContextFingerprint }),
             ...(input.launch.description ? { description: input.launch.description } : {}),
-            ...(isolatedMaintenance ? { skipLocalMemory: true } : {}),
         }), dependencies.cancellation);
     }
     catch (error) {
@@ -273,6 +279,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         }, "workspace_prepare", error);
         throw error;
     }
+    const localMemoryV2Initialized = await initializeLocalMemoryV2ForWorkspace(workspace, input.localMemoryV2Enabled === true);
     let materialized = null;
     let knownAttachmentDirectory = null;
     const startupReservationState = { current: null };
@@ -282,6 +289,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     let memoryPruneFailurePhase = "diagnostics_before";
     let memoryPruneBeforeSnapshot = null;
     let memoryPruneSharedWriteKey = null;
+    let localMemoryResultPath = null;
     let executionWorkspace = workspace;
     let localMemoryTelemetry = null;
     const inheritedEnv = { ...process.env };
@@ -291,23 +299,12 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     }
     const sourceCodexHome = inheritedEnv.CODEX_HOME
         ?? (inheritedEnv.HOME === undefined ? undefined : join(inheritedEnv.HOME, ".codex"));
-    let materializedDeepSeekHome;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
             throw new Error("DeepSeek API key is not configured for this Agent");
         }
         if (isDeepSeekCodex) {
-            const providerBaseUrl = providerConfig.providerBaseUrl
-                ? new URL(providerConfig.providerBaseUrl, input.launch.serverUrl).toString()
-                : undefined;
-            const materialize = dependencies.materializeDeepSeekCodexHome ?? materializeDeepSeekCodexHome;
-            const materializeOptions = {
-                ...(providerBaseUrl === undefined ? {} : { baseUrl: providerBaseUrl }),
-                ...(isolatedMaintenance ? { selfTraining: true } : {}),
-            };
-            materializedDeepSeekHome = await awaitWithCancellation(providerBaseUrl === undefined && !isolatedMaintenance
-                ? materialize(workspace.homeDir)
-                : materialize(workspace.homeDir, materializeOptions), dependencies.cancellation);
+            await awaitWithCancellation((dependencies.materializeDeepSeekCodexHome ?? materializeDeepSeekCodexHome)(workspace.homeDir), dependencies.cancellation);
         }
         const supportsNativeResume = runtime.name === "claude"
             || (dependencies.launchRuntime !== undefined && runtimeCapability(runtime.name).nativeResume);
@@ -377,8 +374,8 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             rotatedForBudget,
             nearBudget,
             ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
+            ...(input.trainingProjectContext === undefined ? {} : { trainingProjectContext: input.trainingProjectContext }),
         };
-        const systemPrompt = resolvePrompt(input.systemPrompt, promptContext);
         if (input.attachments && input.attachments.length > 0) {
             if (dependencies.cancellation?.isRequested())
                 throw new RuntimeCancelledError();
@@ -412,30 +409,52 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const attachmentPlan = routeRuntimeAttachments(runtime.name, materialized?.attachments ?? []);
         const wakePrompt = `${resolvePrompt(input.wakePrompt, promptContext)}${attachmentPlan.promptSuffix}`;
         memoryPruneTraceId = parseMemoryPruneTraceId(wakePrompt);
-        if (!isolatedMaintenance)
-            try {
-                localMemoryTelemetry = createLocalMemoryTelemetry({
-                    executionId: input.executionId,
-                    agentHandle: input.handle,
-                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-                    runtime: runtime.name,
-                    stableProtocolRuntime: dependencies.launchRuntime !== undefined,
-                    agentDir: executionWorkspace.dir,
-                    runDir: executionWorkspace.runDir,
-                    isMemoryPrune: memoryPruneTraceId !== null,
-                    diagnosticsTimeoutMs: dependencies.localMemoryDiagnosticsTimeoutMs
-                        ?? LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS,
-                });
-                await localMemoryTelemetry.captureBefore();
-            }
-            catch (error) {
-                localMemoryTelemetry = null;
-                logLocalMemoryDiagnosticsFailure({
-                    executionId: input.executionId,
-                    agentHandle: input.handle,
-                    ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
-                }, "initialize", error);
-            }
+        if (input.localMemoryV2Enabled === true && memoryPruneTraceId !== null
+            && isLocalMemoryV2Eligible({
+                enabledForHandle: true,
+                agentHomePreexisted: workspace.agentHomePreexisted === true,
+                memorySeedCreated: executionWorkspace.memorySeedCreated === true && (localMemoryV2Initialized || workspace.localMemoryV2Initialized !== false),
+                localMemoryV2Initialized,
+                memoryPrune: true,
+            })) {
+            localMemoryResultPath = makeLocalMemoryResultPath(executionWorkspace.runDir, input.executionId);
+        }
+        const baseSystemPrompt = resolvePrompt(input.systemPrompt, promptContext);
+        const structuredMemoryInstructions = localMemoryResultPath === null
+            ? null
+            : renderLocalMemoryResultInstructions(localMemoryResultPath);
+        const structuredPromptFits = structuredMemoryInstructions === null
+            || input.maxSystemPromptBytes === undefined
+            || Buffer.byteLength(baseSystemPrompt, "utf8") + Buffer.byteLength(structuredMemoryInstructions, "utf8")
+                <= input.maxSystemPromptBytes;
+        if (!structuredPromptFits)
+            localMemoryResultPath = null;
+        const systemPrompt = localMemoryResultPath === null
+            ? baseSystemPrompt
+            : `${baseSystemPrompt}${structuredMemoryInstructions ?? ""}`;
+        try {
+            localMemoryTelemetry = createLocalMemoryTelemetry({
+                executionId: input.executionId,
+                agentHandle: input.handle,
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+                runtime: runtime.name,
+                stableProtocolRuntime: dependencies.launchRuntime !== undefined,
+                agentDir: executionWorkspace.dir,
+                runDir: executionWorkspace.runDir,
+                isMemoryPrune: memoryPruneTraceId !== null,
+                diagnosticsTimeoutMs: dependencies.localMemoryDiagnosticsTimeoutMs
+                    ?? LOCAL_MEMORY_DIAGNOSTICS_TIMEOUT_MS,
+            });
+            await localMemoryTelemetry.captureBefore();
+        }
+        catch (error) {
+            localMemoryTelemetry = null;
+            logLocalMemoryDiagnosticsFailure({
+                executionId: input.executionId,
+                agentHandle: input.handle,
+                ...(input.taskKey === undefined ? {} : { taskKey: input.taskKey }),
+            }, "initialize", error);
+        }
         if (memoryPruneTraceId !== null) {
             memoryPruneSharedWriteKey = JSON.stringify([input.launch.agentsRoot, input.handle]);
             const activePruneCount = (activeMemoryPrunes.get(memoryPruneSharedWriteKey) ?? 0) + 1;
@@ -469,7 +488,6 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             }
         }
         memoryPruneFailurePhase = "runtime_prepare";
-        const crewHome = isolatedMaintenance ? executionWorkspace.runDir : workspace.dir;
         const baseEnv = {
             ...inheritedEnv,
             ...sanitizeEnvVars(providerConfig.envVars),
@@ -478,10 +496,10 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             CREW_SERVER_URL: input.launch.serverUrl,
             CREW_TOKEN: input.launch.token,
             CREW_CHANNEL: input.channelId,
-            CREW_HOME: crewHome,
+            CREW_HOME: workspace.dir,
             // Expose only the training root; ability-specific workspace layout stays
             // owned by the training package rather than the NowWork daemon.
-            QA_RUNTIME_ROOT: join(crewHome, "training"),
+            QA_RUNTIME_ROOT: join(workspace.dir, "training"),
             CREW_TASK_DIR: executionWorkspace.runDir,
             CREW_TASK_LOG: executionWorkspace.workLogPath,
             ...(input.wakeMessageId ? { CREW_WAKE_MESSAGE_ID: input.wakeMessageId } : {}),
@@ -497,7 +515,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
         const providerEnv = applyProviderEnv(baseEnv, runtime.name, input.launch.codexHomeMode === undefined
             ? providerConfig
-            : { ...providerConfig, codexHomeMode: input.launch.codexHomeMode }, workspace.homeDir, materializedDeepSeekHome);
+            : { ...providerConfig, codexHomeMode: input.launch.codexHomeMode }, workspace.homeDir);
         const childEnv = runtime.name === "deepseek-harness"
             ? applyDeepSeekHarnessMachineEnv(providerEnv, inheritedEnv)
             : providerEnv;
@@ -508,7 +526,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             qa_runtime_root: childEnv.QA_RUNTIME_ROOT ?? null,
             qa_runtime_root_present: childEnv.QA_RUNTIME_ROOT !== undefined,
             inherited_qa_runtime_root_present: inheritedEnv.QA_RUNTIME_ROOT !== undefined,
-            training_root: join(crewHome, "training"),
+            training_root: join(workspace.dir, "training"),
             project_context_present: input.projectContext !== undefined,
             project_ids: JSON.stringify(input.projectContext === undefined
                 ? []
@@ -522,7 +540,13 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             ability_release_id: input.abilityRelease?.releaseId,
             ability_root_commit: input.abilityRelease?.rootCommit,
         });
-        const launchRuntime = dependencies.launchRuntime ?? launchLegacyRuntime;
+        const warn = dependencies.warnRuntime ?? warnRuntimeLocally;
+        const launchRuntime = dependencies.launchRuntime ?? (async (launchReq) => {
+            if (launchReq.runtime === "codex" && launchReq.codexCollaborationTools === true) {
+                warn(CODEX_COLLABORATION_EXEC_WARNING);
+            }
+            return launchLegacyRuntime(launchReq);
+        });
         if (dependencies.cancellation?.isRequested())
             throw new RuntimeCancelledError();
         let activeProjectSkillRuntimeRoot;
@@ -567,19 +591,23 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     skill_count: abilityContext.skillCount,
                 });
             }
+            const trainingRoots = input.trainingProjectContext?.projects.map((project) => project.root) ?? [];
             const { codexSkillRoots, claudeAdditionalDirectories } = await projectSkillRuntimeDirectories({
                 runtime: runtime.name,
                 ...(runtimeRoot === undefined ? {} : { runtimeRoot }),
                 agentRoot: workspace.dir,
                 projectSkillsPresent: input.projectSkills !== undefined,
                 ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
+                ...(input.trainingProjectContext === undefined ? {} : {
+                    trainingProjectRoots: input.trainingProjectContext.projects.map((project) => project.root),
+                }),
                 ...(abilityContext?.skillRoot === undefined
                     ? {}
                     : { abilitySkillRoot: abilityContext.skillRoot }),
             });
             let runtimeEnv = childEnv;
             if (runtime.name === "claude"
-                && input.projectContext !== undefined
+                && (input.projectContext !== undefined || trainingRoots.length > 0)
                 && claudeAdditionalDirectories.length > 0) {
                 const version = await (dependencies.probeClaudeVersion ?? probeClaudeVersion)(runtime.name, childEnv)
                     .catch(() => null);
@@ -591,13 +619,15 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 }
                 else {
                     runtimeEnv = withoutClaudeInstructionFlag(childEnv);
-                    (dependencies.warnRuntime ?? warnRuntimeLocally)(CLAUDE_INSTRUCTION_WARNING);
+                    warn(CLAUDE_INSTRUCTION_WARNING);
                     callbacks.onConsole?.({
                         stream: "system",
                         text: `[runtime-warning] ${CLAUDE_INSTRUCTION_WARNING}`,
                     });
                 }
             }
+            const legacyRoots = input.projectContext?.secondary.map((project) => project.root) ?? [];
+            const workspaceRoots = [...legacyRoots, ...trainingRoots];
             const launchRequest = {
                 runtime: runtime.name,
                 bin: runtime.name === "deepseek-harness" ? "dsh-acp-demo" : runtime.name,
@@ -615,6 +645,9 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                 ...(launchReasoning === undefined ? {} : { reasoning: launchReasoning }),
                 ...(launchSessionId === null ? {} : { sessionId: launchSessionId }),
                 resume: resuming,
+                ...(runtime.codexCollaborationTools === undefined
+                    ? {}
+                    : { codexCollaborationTools: runtime.codexCollaborationTools }),
                 ...(attachmentPlan.nativeImagePaths.length > 0
                     ? { imagePaths: attachmentPlan.nativeImagePaths }
                     : {}),
@@ -625,10 +658,14 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
                     ? {}
                     : { claudeAdditionalDirectories }),
                 ...(input.projectContext === undefined ? {} : {
-                    workspaceRoots: Object.freeze(input.projectContext.secondary.map((project) => project.root)),
                     projectContext: input.projectContext,
                 }),
-                ...(isolatedMaintenance && runtime.name === "codex" ? { networkAccess: true } : {}),
+                ...(input.projectContext === undefined && workspaceRoots.length === 0
+                    ? {}
+                    : { workspaceRoots: Object.freeze(workspaceRoots) }),
+                ...(input.trainingProjectContext === undefined ? {} : {
+                    trainingProjectContext: input.trainingProjectContext,
+                }),
             };
             return launchRequest;
         };
@@ -902,6 +939,24 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const { exitCode, spawnError, terminationSignal } = runtimeExit;
         localMemoryTelemetry?.markRuntimeExited(exitCode);
         memoryPruneRuntimeExitCode = exitCode;
+        if (localMemoryResultPath !== null) {
+            const committed = await commitLocalMemoryResultAfterExit({
+                resultPath: localMemoryResultPath,
+                agentDir: executionWorkspace.dir,
+                executionId: input.executionId,
+                pruneTraceId: memoryPruneTraceId,
+                exitCode,
+            });
+            if (committed.status === "failed") {
+                dslog("local_memory.commit_failed", "结构化本地记忆候选未落地，保留结果文件", {
+                    level: "WARN",
+                    execution_id: input.executionId,
+                    agent_handle: input.handle,
+                    error_code: committed.error,
+                    result_path: localMemoryResultPath,
+                });
+            }
+        }
         const errorTail = [
             stderrTail.trim(),
             spawnError === undefined
@@ -1075,8 +1130,5 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             const detail = error instanceof Error ? error.message : String(error);
             process.stderr.write(`[execution] failed to remove prompt ${workspace.systemPromptPath}: ${detail}\n`);
         }
-        if (isolatedMaintenance) {
-            await cleanupSelfTrainingRunDir(join(workspace.dir, "tasks"), executionWorkspace.runDir);
-        }
     }
 }

package/dist/local-memory/index-budget.js

@@ -0,0 +1,74 @@
+export const LOCAL_MEMORY_TOTAL_CODE_POINT_CAP = 6_000;
+export const LOCAL_MEMORY_INDEX_CODE_POINT_CAP = 3_000;
+export const LOCAL_MEMORY_INDEX_ENTRY_CAP = 20;
+const PROJECTABLE_STATUSES = new Set(["pinned", "active"]);
+function codePointLength(value) {
+    return Array.from(value).length;
+}
+export function renderLocalMemoryIndexCard(entry) {
+    return `### ${entry.title}\n`
+        + `- id: ${entry.id}\n`
+        + `- file: ${entry.file}\n`
+        + `- type: ${entry.type}\n`
+        + `- status: ${entry.status}\n`
+        + `- summary: ${entry.summary}\n`
+        + `- triggers: ${entry.triggers.join(", ")}\n`
+        + `- priority: ${entry.priority}\n`
+        + `- revision: ${entry.revision}\n`
+        + `- anchor: ${entry.anchor ?? ""}\n`
+        + `- updated: ${entry.updated}\n`
+        + (entry.reviewAfter === null ? "" : `- review_after: ${entry.reviewAfter}\n`);
+}
+function compareEntries(left, right) {
+    const statusRank = (status) => status === "pinned" ? 0 : 1;
+    const priorityRank = (priority) => (priority === "high" ? 0 : priority === "medium" ? 1 : 2);
+    return statusRank(left.status) - statusRank(right.status)
+        || priorityRank(left.priority) - priorityRank(right.priority)
+        || right.updated.localeCompare(left.updated)
+        || left.id.localeCompare(right.id);
+}
+function cardLength(entry, hasPrevious) {
+    return codePointLength(renderLocalMemoryIndexCard(entry)) + (hasPrevious ? 1 : 0);
+}
+function overBudgetReason(entries) {
+    return entries.some((entry) => entry.status === "pinned")
+        ? "index_over_budget_pinned"
+        : "index_over_budget_active";
+}
+export function selectLocalMemoryIndexEntries(entries, budget, options = {}) {
+    const projectable = entries.filter((entry) => PROJECTABLE_STATUSES.has(entry.status));
+    const omittedIds = entries
+        .filter((entry) => !PROJECTABLE_STATUSES.has(entry.status))
+        .map((entry) => entry.id);
+    const protectedIds = options.protectedIds ?? new Set();
+    const protectedEntries = projectable.filter((entry) => protectedIds.has(entry.id)).sort(compareEntries);
+    const candidates = projectable.filter((entry) => !protectedIds.has(entry.id)).sort(compareEntries);
+    const selected = [];
+    let renderedLength = 0;
+    for (const entry of protectedEntries) {
+        selected.push(entry);
+        renderedLength += cardLength(entry, selected.length > 1);
+    }
+    if (selected.length > budget.entryCap || renderedLength > budget.indexCodePointCap) {
+        return {
+            entries: selected,
+            omittedIds: [...omittedIds, ...candidates.map((entry) => entry.id)],
+            reason: overBudgetReason(selected),
+        };
+    }
+    for (const entry of candidates) {
+        if (selected.length >= budget.entryCap || renderedLength + cardLength(entry, selected.length > 0) > budget.indexCodePointCap) {
+            omittedIds.push(entry.id);
+            continue;
+        }
+        selected.push(entry);
+        renderedLength += cardLength(entry, selected.length > 1);
+    }
+    return {
+        entries: selected,
+        omittedIds,
+        reason: omittedIds.length === entries.filter((item) => !PROJECTABLE_STATUSES.has(item.status)).length
+            ? null
+            : "index_over_budget",
+    };
+}

package/dist/local-memory/pending.js

@@ -0,0 +1,111 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, readdir, realpath, rename, rm, writeFile, readFile } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+const CandidateSchema = z.object({
+    operation: z.enum(["create", "update", "supersede"]),
+    memoryId: z.string().nullable(),
+    baseRevision: z.number().int().nonnegative().nullable(),
+    supersedesMemoryId: z.string().nullable(),
+    title: z.string().min(1),
+    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
+    summary: z.string().min(1),
+    triggers: z.array(z.string()).min(1),
+    priority: z.enum(["high", "medium", "low"]),
+    detailCategory: z.enum(["preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons"]),
+    detailBody: z.string().min(1),
+    reviewAfter: z.string().nullable(),
+}).strict();
+const PendingSchema = z.object({
+    schemaVersion: z.literal(1),
+    pendingId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    createdAt: z.string().min(1),
+    reason: z.literal("index_over_budget"),
+    source: z.object({
+        executionId: z.string().min(1),
+        pruneTraceId: z.string().min(1).nullable(),
+    }).strict(),
+    candidate: CandidateSchema,
+}).strict();
+function within(root, candidate) {
+    const path = relative(root, candidate);
+    return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
+}
+async function pendingDirectory(agentDir) {
+    const agentRoot = await realpath(agentDir);
+    const memoryRoot = resolve(agentRoot, ".crew", "memory");
+    await mkdir(memoryRoot, { recursive: true });
+    const memoryStat = await lstat(memoryRoot);
+    if (!memoryStat.isDirectory() || memoryStat.isSymbolicLink())
+        throw new Error("local_memory_pending_path_invalid");
+    const resolvedMemoryRoot = await realpath(memoryRoot);
+    if (resolvedMemoryRoot !== memoryRoot || !within(agentRoot, resolvedMemoryRoot)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    const directory = join(memoryRoot, "pending");
+    try {
+        const stat = await lstat(directory);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error("local_memory_pending_path_invalid");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        await mkdir(directory);
+    }
+    const resolvedDirectory = await realpath(directory);
+    if (resolvedDirectory !== directory || !within(agentRoot, resolvedDirectory)) {
+        throw new Error("local_memory_pending_path_invalid");
+    }
+    return directory;
+}
+async function assertRegularFile(path) {
+    try {
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("local_memory_pending_path_invalid");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function atomicWrite(path, content) {
+    const temporary = join(dirname(path), `.${basename(path)}.tmp-${randomUUID()}`);
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600, flag: "wx" });
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function persistPendingMemoryCandidate(input) {
+    const parsed = PendingSchema.safeParse(input.candidate);
+    if (!parsed.success)
+        throw new Error("local_memory_pending_invalid");
+    const directory = await pendingDirectory(input.agentDir);
+    const target = join(directory, `${parsed.data.pendingId}.json`);
+    await assertRegularFile(target);
+    await atomicWrite(target, `${JSON.stringify(parsed.data, null, 2)}\n`);
+    return target;
+}
+export async function readPendingMemoryCandidates(input) {
+    const directory = await pendingDirectory(input.agentDir);
+    const names = (await readdir(directory)).filter((name) => name.endsWith(".json")).sort();
+    const result = [];
+    for (const name of names) {
+        const path = join(directory, name);
+        try {
+            await assertRegularFile(path);
+            const parsed = PendingSchema.safeParse(JSON.parse(await readFile(path, "utf8")));
+            if (parsed.success && `${parsed.data.pendingId}.json` === name)
+                result.push(parsed.data);
+        }
+        catch {
+            // A damaged pending item is diagnosable and must not hide other candidates.
+        }
+    }
+    return result;
+}

package/dist/local-memory/runtime.js

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { applyLocalMemoryResult, parseLocalMemoryResult } from "./write.js";
+export function isLocalMemoryV2Eligible(input) {
+    return input.enabledForHandle
+        && (input.localMemoryV2Initialized || (!input.agentHomePreexisted && input.memorySeedCreated))
+        && input.memoryPrune;
+}
+const LOCAL_MEMORY_V2_MARKER = "v2-enabled";
+export async function initializeLocalMemoryV2(agentDir) {
+    const crewDir = join(agentDir, ".crew");
+    const memoryDir = join(crewDir, "memory");
+    await mkdir(crewDir, { recursive: true });
+    const crewStat = await lstat(crewDir);
+    if (!crewStat.isDirectory() || crewStat.isSymbolicLink())
+        throw new Error("local_memory_marker_path_invalid");
+    await mkdir(memoryDir, { recursive: true });
+    const memoryStat = await lstat(memoryDir);
+    if (!memoryStat.isDirectory() || memoryStat.isSymbolicLink())
+        throw new Error("local_memory_marker_path_invalid");
+    try {
+        await writeFile(join(memoryDir, LOCAL_MEMORY_V2_MARKER), "1\n", { encoding: "utf8", mode: 0o600, flag: "wx" });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
+}
+export async function initializeLocalMemoryV2ForWorkspace(workspace, enabledForHandle) {
+    const initialized = workspace.localMemoryV2Initialized === true;
+    if (!enabledForHandle || initialized || workspace.localMemoryV2Initialized !== false
+        || workspace.agentHomePreexisted === true || workspace.memorySeedCreated !== true)
+        return initialized;
+    try {
+        await initializeLocalMemoryV2(workspace.dir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function localMemoryResultPath(runDir, executionId) {
+    const suffix = createHash("sha256").update(executionId, "utf8").digest("hex").slice(0, 32);
+    return join(runDir, `.memory-result.v1-${suffix}.json`);
+}
+export function renderLocalMemoryResultInstructions(resultPath) {
+    return `
+
+## Structured memory prune (daemon-managed)
+本轮长期记忆收尾只提交候选，不要直接编辑 $CREW_HOME/MEMORY.md 或 $CREW_HOME/notes/。
+将一个合法 JSON 对象写入以下 daemon 提供的文件，写入完成后再结束本轮：
+${resultPath}
+
+JSON 顶层必须包含：
+{"schemaVersion":1,"purpose":"memory_prune","baseCatalogRevision":0,"outcome":"no_change","changes":[],"statusChanges":[]}
+每个 changes 项使用 operation=create|update|supersede、title、kind、summary、triggers、priority、detailCategory、detailBody、reviewAfter；create 的 memoryId/baseRevision/supersedesMemoryId 必须为 null，update/supersede 按现有索引填写版本和 id。
+只提交可复用、与本次任务明确相关的少量候选；不要写入凭证、token、隐私或内部控制标记。daemon 会校验、去重、限制 MEMORY.md 大小，超出索引容量的候选会保存在 pending 中等待后续治理。
+`;
+}
+export async function commitLocalMemoryResultAfterExit(input) {
+    if (input.exitCode !== 0)
+        return { status: "skipped" };
+    let raw;
+    try {
+        raw = await readFile(input.resultPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { status: "missing" };
+        return { status: "failed", error: error instanceof Error ? error.message : "read_failed" };
+    }
+    try {
+        const result = parseLocalMemoryResult(raw);
+        await applyLocalMemoryResult({
+            agentDir: input.agentDir,
+            result,
+            executionId: input.executionId,
+            pruneTraceId: input.pruneTraceId,
+        });
+        await rm(input.resultPath, { force: true });
+        return { status: "applied" };
+    }
+    catch (error) {
+        return { status: "failed", error: error instanceof Error ? error.message : "apply_failed" };
+    }
+}

package/dist/local-memory/types.js

@@ -0,0 +1 @@
+export {};