@nowcrew/daemon 0.6.64 → 0.6.65

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

package/dist/local-memory/write.js

@@ -0,0 +1,448 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+import { containsLikelySecret } from "../agent-memory/policy.js";
+import { LOCAL_MEMORY_INDEX_CODE_POINT_CAP, LOCAL_MEMORY_INDEX_ENTRY_CAP, LOCAL_MEMORY_TOTAL_CODE_POINT_CAP, renderLocalMemoryIndexCard, selectLocalMemoryIndexEntries, } from "./index-budget.js";
+import { persistPendingMemoryCandidate } from "./pending.js";
+const CategorySchema = z.enum([
+    "preferences", "project-rules", "testing", "debugging", "git", "incidents", "lessons",
+]);
+const SingleLineText = z.string().trim().min(1).max(500).regex(/^[^\r\n]+$/u);
+const ChangeSchema = z.object({
+    operation: z.enum(["create", "update", "supersede"]),
+    memoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
+    baseRevision: z.number().int().nonnegative().nullable(),
+    supersedesMemoryId: SingleLineText.regex(/^[^<>]+$/u).nullable(),
+    title: SingleLineText.max(120),
+    kind: z.enum(["procedural", "semantic", "episodic", "preference"]),
+    summary: SingleLineText,
+    triggers: z.array(SingleLineText.max(80)).min(1).max(16),
+    priority: z.enum(["high", "medium", "low"]),
+    detailCategory: CategorySchema,
+    detailBody: z.string().trim().min(1).max(12_000),
+    reviewAfter: SingleLineText.nullable(),
+}).strict();
+const StatusChangeSchema = z.object({
+    memoryId: SingleLineText,
+    expectedRevision: z.number().int().positive(),
+    expectedStatus: z.enum(["candidate", "active", "pinned", "stale", "superseded", "archived"]),
+    targetStatus: z.enum(["candidate", "active", "pinned", "stale", "archived"]),
+    reason: z.enum(["user_explicit", "manual_review"]),
+}).strict();
+const ResultSchema = z.object({
+    schemaVersion: z.literal(1),
+    purpose: z.literal("memory_prune"),
+    baseCatalogRevision: z.number().int().nonnegative(),
+    outcome: z.enum(["no_change", "proposed", "conflict", "failed"]),
+    changes: z.array(ChangeSchema).max(50),
+    statusChanges: z.array(StatusChangeSchema).max(50),
+}).strict();
+const GENERATED_INDEX_PATTERN = /<!--\s*NOWWORK:MEMORY_INDEX:BEGIN\s+schema=1\s*-->[\s\S]*?<!--\s*NOWWORK:MEMORY_INDEX:END\s*-->/u;
+const INDEX_HEADING = /^##\s+Knowledge Index\s*$/mu;
+const NEXT_SECTION = /^##\s+(?!#)/mu;
+const CARD_HEADING = /^###\s+(.+?)\s*$/gmu;
+const FIELD_LINE = /^-\s+([a-z][a-z_]*)\s*:\s*(.*?)\s*$/iu;
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
+const RESERVED_MEMORY_MARKER = /NOWWORK:(?:MEMORY_ENTRY|MEMORY_INDEX):/iu;
+function codePointLength(value) {
+    return Array.from(value).length;
+}
+function detailPath(category) {
+    return `notes/${category}.md`;
+}
+function parseStatus(value) {
+    return value === "candidate" || value === "active" || value === "pinned"
+        || value === "stale" || value === "superseded" || value === "archived"
+        ? value
+        : "active";
+}
+function parseCard(titleLine, body) {
+    const fields = {};
+    for (const line of body.split(/\r?\n/u)) {
+        const match = FIELD_LINE.exec(line);
+        if (match?.[1] !== undefined && match[2] !== undefined)
+            fields[match[1].toLowerCase()] = match[2];
+    }
+    const title = titleLine.trim().replace(/^\[|\]$/gu, "").trim();
+    const file = fields.file?.trim();
+    if (!title || !file)
+        return null;
+    const priority = fields.priority === "high" || fields.priority === "low" ? fields.priority : "medium";
+    const revision = Number(fields.revision);
+    return {
+        id: fields.id?.trim() || `legacy:${file}:${title}`,
+        title,
+        file,
+        type: fields.type === "procedural" || fields.type === "episodic" || fields.type === "preference"
+            ? fields.type
+            : "semantic",
+        status: parseStatus(fields.status),
+        summary: fields.summary?.trim() ?? "",
+        triggers: [...new Set((fields.triggers ?? "").split(/[,，、]/u).map((value) => value.trim()).filter(Boolean))],
+        priority,
+        updated: fields.updated?.trim() ?? "",
+        anchor: fields.anchor?.trim() || null,
+        revision: Number.isInteger(revision) && revision > 0 ? revision : 1,
+        reviewAfter: fields.review_after?.trim() || null,
+    };
+}
+function indexSection(memory) {
+    const heading = INDEX_HEADING.exec(memory);
+    if (heading === null || heading.index === undefined)
+        return "";
+    const start = heading.index + heading[0].length;
+    const rest = memory.slice(start);
+    const next = NEXT_SECTION.exec(rest);
+    return next?.index === undefined ? rest : rest.slice(0, next.index);
+}
+function parseCards(section) {
+    const withoutComments = section.replace(/<!--[\s\S]*?-->/gu, "");
+    const headings = [...withoutComments.matchAll(CARD_HEADING)];
+    return headings.flatMap((heading, index) => {
+        if (heading.index === undefined || heading[1] === undefined)
+            return [];
+        const bodyStart = heading.index + heading[0].length;
+        const bodyEnd = headings[index + 1]?.index ?? withoutComments.length;
+        const card = parseCard(heading[1], withoutComments.slice(bodyStart, bodyEnd));
+        return card === null ? [] : [card];
+    });
+}
+export function parseLocalMemoryIndex(memory) {
+    const section = indexSection(memory);
+    const generated = GENERATED_INDEX_PATTERN.exec(section)?.[0];
+    return parseCards(generated ?? section);
+}
+function parseUnmarkedMemoryIndex(memory) {
+    const section = indexSection(memory).replace(GENERATED_INDEX_PATTERN, "");
+    return parseCards(section);
+}
+function renderGeneratedIndex(entries) {
+    const cards = entries
+        .filter((entry) => entry.status === "pinned" || entry.status === "active")
+        .map(renderLocalMemoryIndexCard)
+        .join("\n");
+    return `<!-- NOWWORK:MEMORY_INDEX:BEGIN schema=1 -->\n${cards}<!-- NOWWORK:MEMORY_INDEX:END -->`;
+}
+function replaceGeneratedIndex(memory, entries) {
+    const generated = renderGeneratedIndex(entries);
+    if (GENERATED_INDEX_PATTERN.test(memory))
+        return memory.replace(GENERATED_INDEX_PATTERN, generated);
+    const heading = INDEX_HEADING.exec(memory);
+    if (heading?.index !== undefined) {
+        const afterHeading = heading.index + heading[0].length;
+        return `${memory.slice(0, afterHeading)}\n${generated}${memory.slice(afterHeading)}`;
+    }
+    return `${memory.trimEnd()}\n\n## Knowledge Index\n${generated}\n`;
+}
+function noteSection(id, revision, title, body) {
+    return `<!-- NOWWORK:MEMORY_ENTRY:BEGIN id=${id} revision=${revision} -->\n`
+        + `## ${title}\n\n${body.trim()}\n`
+        + `<!-- NOWWORK:MEMORY_ENTRY:END id=${id} -->\n`;
+}
+function notePattern(id) {
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    return new RegExp(`<!--\\s*NOWWORK:MEMORY_ENTRY:BEGIN\\s+id=${escaped}[^>]*-->[\\s\\S]*?<!--\\s*NOWWORK:MEMORY_ENTRY:END\\s+id=${escaped}\\s*-->\\s*`, "u");
+}
+function replaceNote(content, id, replacement) {
+    const pattern = notePattern(id);
+    return pattern.test(content) ? content.replace(pattern, replacement) : null;
+}
+function containsReservedText(change) {
+    return RESERVED_MEMORY_MARKER.test([change.title, change.summary, ...change.triggers, change.detailBody].join("\n"));
+}
+function validateCandidate(result) {
+    if (result.outcome === "no_change" && (result.changes.length > 0 || result.statusChanges.length > 0)) {
+        throw new Error("local_memory_no_change_has_operations");
+    }
+    for (const change of result.changes) {
+        const text = [change.title, change.summary, ...change.triggers, change.detailBody].join("\n");
+        if (containsLikelySecret(text))
+            throw new Error("local_memory_secret_candidate");
+        if (CONTROL_CHARACTER_PATTERN.test(text))
+            throw new Error("local_memory_control_character");
+        if (containsReservedText(change))
+            throw new Error("local_memory_reserved_marker");
+        if (change.operation === "create"
+            && (change.memoryId !== null || change.baseRevision !== null || change.supersedesMemoryId !== null)) {
+            throw new Error("local_memory_create_revision_invalid");
+        }
+        if (change.operation === "update"
+            && (change.memoryId === null || change.baseRevision === null || change.supersedesMemoryId !== null)) {
+            throw new Error("local_memory_update_revision_missing");
+        }
+        if (change.operation === "supersede"
+            && (change.memoryId !== null || change.baseRevision === null || change.supersedesMemoryId === null)) {
+            throw new Error("local_memory_supersede_revision_missing");
+        }
+    }
+}
+export function parseLocalMemoryResult(raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("local_memory_result_json_invalid");
+    }
+    const parsed = ResultSchema.safeParse(value);
+    if (!parsed.success)
+        throw new Error(`local_memory_result_invalid:${parsed.error.issues[0]?.path.join(".") ?? "unknown"}`);
+    validateCandidate(parsed.data);
+    return parsed.data;
+}
+function entryFromChange(change, id, revision, status) {
+    return {
+        id,
+        title: change.title,
+        file: detailPath(change.detailCategory),
+        type: change.kind,
+        status,
+        summary: change.summary,
+        triggers: [...new Set(change.triggers)],
+        priority: change.priority,
+        updated: new Date().toISOString().slice(0, 10),
+        anchor: id,
+        revision,
+        reviewAfter: change.reviewAfter,
+    };
+}
+function matchesCreateCandidate(entry, change) {
+    const triggers = [...new Set(change.triggers)];
+    return entry.title === change.title
+        && entry.file === detailPath(change.detailCategory)
+        && entry.type === change.kind
+        && entry.summary === change.summary
+        && entry.priority === change.priority
+        && entry.reviewAfter === change.reviewAfter
+        && entry.triggers.length === triggers.length
+        && entry.triggers.every((trigger, index) => trigger === triggers[index]);
+}
+function stableId(executionId, index, change) {
+    const input = [executionId, String(index), change.operation, change.title, change.summary, change.detailBody].join("\0");
+    return `mem_${createHash("sha256").update(input, "utf8").digest("hex").slice(0, 12)}`;
+}
+function normalize(value) {
+    return value.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
+}
+function activeOrPinnedIds(entries) {
+    return new Set(entries.filter((entry) => entry.status === "active" || entry.status === "pinned").map((entry) => entry.id));
+}
+function emptyResult() {
+    return { createdIds: [], updatedIds: [], statusChangedIds: [], deferredIds: [], pendingIds: [] };
+}
+function isWithin(root, candidate) {
+    const path = relative(root, candidate);
+    return path === "" || (path !== ".." && !path.startsWith(`..${sep}`));
+}
+async function assertWritablePaths(agentDir, memoryPath) {
+    const agentRoot = await realpath(agentDir);
+    const notesPath = join(agentDir, "notes");
+    const notesRoot = await realpath(notesPath);
+    if (notesRoot !== resolve(agentRoot, "notes") || !isWithin(agentRoot, notesRoot))
+        throw new Error("local_memory_notes_path_invalid");
+    const memoryStat = await lstat(memoryPath);
+    if (!memoryStat.isFile() || memoryStat.isSymbolicLink())
+        throw new Error("local_memory_memory_path_invalid");
+}
+async function readNote(path) {
+    try {
+        const stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error("local_memory_note_path_invalid");
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    }
+}
+async function atomicWrite(path, content) {
+    const temporary = `${path}.tmp-${randomUUID()}`;
+    try {
+        await writeFile(temporary, content, { encoding: "utf8", mode: 0o600 });
+        await rename(temporary, path);
+    }
+    catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+function projectIndex(memory, entries, protectedIds) {
+    const empty = replaceGeneratedIndex(memory, []);
+    if (codePointLength(empty) > LOCAL_MEMORY_TOTAL_CODE_POINT_CAP)
+        throw new Error("local_memory_memory_over_budget");
+    const emptyIndex = renderGeneratedIndex([]);
+    const remainingTotal = LOCAL_MEMORY_TOTAL_CODE_POINT_CAP - codePointLength(empty);
+    const selection = selectLocalMemoryIndexEntries(entries, {
+        indexCodePointCap: Math.min(Math.max(0, LOCAL_MEMORY_INDEX_CODE_POINT_CAP - codePointLength(emptyIndex)), remainingTotal),
+        entryCap: LOCAL_MEMORY_INDEX_ENTRY_CAP,
+    }, { protectedIds });
+    return {
+        memory: replaceGeneratedIndex(memory, selection.entries),
+        omittedIds: selection.omittedIds,
+        reason: selection.reason,
+    };
+}
+const applyTails = new Map();
+async function withApplyLease(agentDir, operation) {
+    const key = resolve(agentDir);
+    const previous = applyTails.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolveCurrent) => { release = resolveCurrent; });
+    const tail = previous.then(() => current);
+    applyTails.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        void tail.then(() => {
+            if (applyTails.get(key) === tail)
+                applyTails.delete(key);
+        });
+    }
+}
+export async function applyLocalMemoryResult(input) {
+    validateCandidate(input.result);
+    if (input.result.outcome !== "proposed")
+        return emptyResult();
+    const memoryPath = join(input.agentDir, "MEMORY.md");
+    await assertWritablePaths(input.agentDir, memoryPath);
+    return withApplyLease(input.agentDir, async () => {
+        const memory = await readFile(memoryPath, "utf8");
+        if (parseUnmarkedMemoryIndex(memory).length > 0)
+            throw new Error("local_memory_legacy_index_requires_migration");
+        let entries = [...parseLocalMemoryIndex(memory)];
+        for (const entry of entries) {
+            if (!isWithin(resolve(input.agentDir, "notes"), resolve(input.agentDir, entry.file))) {
+                throw new Error("local_memory_note_path_invalid");
+            }
+        }
+        const contentIds = new Set(input.result.changes.flatMap((change) => [
+            ...(change.operation === "update" && change.memoryId !== null ? [change.memoryId] : []),
+            ...(change.supersedesMemoryId === null ? [] : [change.supersedesMemoryId]),
+        ]));
+        for (const statusChange of input.result.statusChanges) {
+            if (contentIds.has(statusChange.memoryId))
+                throw new Error("local_memory_status_conflict");
+            const current = entries.find((entry) => entry.id === statusChange.memoryId);
+            if (current === undefined || current.revision !== statusChange.expectedRevision || current.status !== statusChange.expectedStatus) {
+                throw new Error("local_memory_status_conflict");
+            }
+            entries = entries.map((entry) => entry.id === statusChange.memoryId
+                ? { ...entry, status: statusChange.targetStatus, revision: entry.revision + 1 }
+                : entry);
+        }
+        const createdIds = [];
+        const updatedIds = [];
+        const statusChangedIds = input.result.statusChanges.map((change) => change.memoryId);
+        const deferredIds = [];
+        const pendingCandidates = [];
+        const noteUpdates = new Map();
+        const randomId = input.randomId ?? randomUUID;
+        const executionId = input.executionId ?? "unknown";
+        const defer = (change, index) => {
+            const candidateId = input.executionId === undefined ? `mem_${randomId()}` : stableId(executionId, index, change);
+            const pendingId = `pending-${candidateId.slice("mem_".length)}`;
+            pendingCandidates.push({
+                schemaVersion: 1,
+                pendingId,
+                createdAt: new Date().toISOString(),
+                reason: "index_over_budget",
+                source: { executionId, pruneTraceId: input.pruneTraceId ?? null },
+                candidate: change,
+            });
+            deferredIds.push(pendingId);
+        };
+        for (const [index, change] of input.result.changes.entries()) {
+            const id = change.operation === "update"
+                ? change.memoryId
+                : input.executionId === undefined ? `mem_${randomId()}` : stableId(executionId, index, change);
+            const existingCreate = change.operation === "create" ? entries.find((entry) => entry.id === id) : undefined;
+            const current = change.operation === "update" ? entries.find((entry) => entry.id === id) : undefined;
+            if (change.operation === "update") {
+                if (current === undefined)
+                    throw new Error("local_memory_revision_conflict_missing_id");
+                if (change.baseRevision !== current.revision)
+                    throw new Error("local_memory_revision_conflict");
+            }
+            const superseded = change.operation === "supersede"
+                ? entries.find((entry) => entry.id === change.supersedesMemoryId)
+                : undefined;
+            if (change.operation === "supersede") {
+                if (superseded === undefined)
+                    throw new Error("local_memory_supersede_missing_id");
+                if (change.baseRevision !== superseded.revision)
+                    throw new Error("local_memory_supersede_revision_conflict");
+            }
+            if (change.operation === "create") {
+                if (existingCreate !== undefined && !matchesCreateCandidate(existingCreate, change)) {
+                    throw new Error("local_memory_duplicate_candidate");
+                }
+                if (existingCreate === undefined && entries.some((entry) => normalize(entry.title) === normalize(change.title)
+                    || normalize(entry.summary) === normalize(change.summary))) {
+                    throw new Error("local_memory_duplicate_candidate");
+                }
+            }
+            const revision = existingCreate?.revision ?? (current === undefined ? 1 : current.revision + 1);
+            const entry = existingCreate ?? entryFromChange(change, id, revision, current?.status ?? "active");
+            const candidateEntries = existingCreate !== undefined
+                ? entries
+                : change.supersedesMemoryId === null
+                    ? current === undefined ? [...entries, entry] : entries.map((item) => item.id === id ? entry : item)
+                    : [
+                        ...entries.map((item) => item.id === change.supersedesMemoryId
+                            ? { ...item, status: "superseded", revision: item.revision + 1 }
+                            : item),
+                        entry,
+                    ];
+            const protectedIds = new Set(activeOrPinnedIds(entries));
+            if (change.supersedesMemoryId !== null)
+                protectedIds.delete(change.supersedesMemoryId);
+            const projection = projectIndex(memory, candidateEntries, protectedIds);
+            const omitted = (entry.status === "active" || entry.status === "pinned") && projection.omittedIds.includes(id);
+            if (change.operation === "update" && omitted)
+                throw new Error(projection.reason ?? "local_memory_index_over_budget");
+            if ((change.operation === "create" || change.operation === "supersede") && omitted) {
+                defer(change, index);
+                continue;
+            }
+            const notePath = resolve(input.agentDir, entry.file);
+            if (!isWithin(resolve(input.agentDir, "notes"), notePath))
+                throw new Error("local_memory_note_path_invalid");
+            const previous = noteUpdates.get(notePath) ?? await readNote(notePath);
+            const replacement = noteSection(id, revision, change.title, change.detailBody);
+            const existingSection = replaceNote(previous, id, replacement);
+            const next = existingSection ?? (current === undefined
+                ? `${previous.trimEnd()}${previous.trimEnd() ? "\n\n" : ""}${replacement}`
+                : null);
+            if (next === null)
+                throw new Error("local_memory_note_anchor_missing");
+            noteUpdates.set(notePath, next);
+            entries = candidateEntries;
+            if (change.operation === "update")
+                updatedIds.push(id);
+            else if (existingCreate === undefined)
+                createdIds.push(id);
+        }
+        const finalProjection = projectIndex(memory, entries, activeOrPinnedIds(entries));
+        if (finalProjection.reason !== null)
+            throw new Error(finalProjection.reason);
+        for (const candidate of pendingCandidates)
+            await persistPendingMemoryCandidate({ agentDir: input.agentDir, candidate });
+        for (const [path, content] of noteUpdates)
+            await atomicWrite(path, content);
+        if (noteUpdates.size > 0 || statusChangedIds.length > 0)
+            await atomicWrite(memoryPath, finalProjection.memory);
+        return {
+            createdIds,
+            updatedIds,
+            statusChangedIds,
+            deferredIds,
+            pendingIds: deferredIds,
+        };
+    });
+}

package/dist/machine-info.js

@@ -191,10 +191,11 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
             profileName: dependencies.profileName,
             daemonHome: dependencies.daemonHome ?? daemonHome(),
             agentsRoot,
-            ...(dependencies.profileName.match(/^nw-(?:in|dev)-([a-z0-9][a-z0-9_-]{0,39})$/u)?.[1] === undefined
+            ...(dependencies.profileName.match(/^nw-(?:production|in|dev)-([a-z0-9][a-z0-9_-]{0,39})$/u)?.[1] === undefined
                 ? {}
-                : { localInstanceName: dependencies.profileName.match(/^nw-(?:in|dev)-([a-z0-9][a-z0-9_-]{0,39})$/u)[1] }),
+                : { localInstanceName: dependencies.profileName.match(/^nw-(?:production|in|dev)-([a-z0-9][a-z0-9_-]{0,39})$/u)[1] }),
         }),
+        ...(dependencies.storageIdentity ?? {}),
         ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
             executionLimits: Object.freeze({