@nowcrew/daemon 0.6.66 → 0.6.67

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