@nowcrew/daemon 0.6.63 → 0.6.65

package/dist/local-executor.js

@@ -31,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)) {
@@ -77,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",
@@ -277,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 };
@@ -286,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 };
@@ -371,7 +375,6 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
             nearBudget,
             ...(input.projectContext === undefined ? {} : { projectContext: input.projectContext }),
         };
-        const systemPrompt = resolvePrompt(input.systemPrompt, promptContext);
         if (input.attachments && input.attachments.length > 0) {
             if (dependencies.cancellation?.isRequested())
                 throw new RuntimeCancelledError();
@@ -405,6 +408,29 @@ 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 (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,
@@ -513,7 +539,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;
@@ -582,7 +614,7 @@ 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}`,
@@ -606,6 +638,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 }
                     : {}),
@@ -892,6 +927,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

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 {};