@nowcrew/daemon 0.6.63 → 0.6.65

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({

package/dist/main.js

@@ -7,6 +7,7 @@
  */
 import { parseArgs } from "node:util";
 import { homedir } from "node:os";
+import { join } from "node:path";
 import { loadConfig, ConfigError } from "./config.js";
 import { detectDaemonLang, formatDaemonText, translateDaemon } from "./i18n.js";
 import { cliVersion, daemonVersion } from "./machine-info.js";
@@ -21,7 +22,18 @@ import { formatDaemonStartupError } from "./daemon-startup-error.js";
 import { assertManagedServiceStartup } from "./managed-service-startup.js";
 import { daemonGlobalInstallation } from "./daemon-installation.js";
 import { acquireDaemonInstallationLease, runWithDaemonInstallationLease, } from "./daemon-installation-lease.js";
+import { loadStorageRuntime } from "./storage-runtime.js";
+import { readStorageMigrationReceipt } from "./storage-migration-controller.js";
+import { storageMigrationStatusReplay } from "./storage-status-replay.js";
+import { runStorageWorkerCommand } from "./storage-worker-command.js";
+import { probeStorageMigrationRuntime } from "./storage-runtime-readiness.js";
+import { createStorageTargetConfirmationHandler } from "./storage-target-confirmation.js";
 async function main() {
+    const workerResult = await runStorageWorkerCommand(process.argv.slice(2));
+    if (workerResult !== null) {
+        process.exitCode = workerResult;
+        return;
+    }
     const computerResult = await runComputerCommand(process.argv.slice(2));
     if (computerResult !== null) {
         process.exitCode = computerResult;
@@ -57,8 +69,10 @@ async function main() {
     // 不把 machine token 放进 argv / plist / systemd unit / scheduled task。
     if (values["daemon-home"])
         process.env.CREW_DAEMON_HOME = values["daemon-home"];
+    let activeDaemonHome;
     if (values.profile) {
         const home = daemonHome();
+        activeDaemonHome = home;
         const profile = await loadProfile(values.profile, home);
         if (cmd === "serve") {
             await assertProfileAgentsRootUnique(profile, home, homedir());
@@ -71,6 +85,12 @@ async function main() {
                 agentsRoot: resolveAgentsRoot(profile.agentsRoot, homedir(), process.platform),
                 nodePath: process.execPath,
                 entryPath: builtDaemonEntry(),
+                environment: {
+                    ...(process.env.NOWWORK_HOME === undefined ? {} : { NOWWORK_HOME: process.env.NOWWORK_HOME }),
+                    ...(process.env.NOWWORK_ENV_TAG === undefined ? {} : { NOWWORK_ENV_TAG: process.env.NOWWORK_ENV_TAG }),
+                    ...(process.env.NOWWORK_STORAGE_POLICY_PATH === undefined
+                        ? {} : { NOWWORK_STORAGE_POLICY_PATH: process.env.NOWWORK_STORAGE_POLICY_PATH }),
+                },
             });
         }
         applyProfileToEnv(profile, process.env);
@@ -100,9 +120,72 @@ async function main() {
         const installationLease = installation === null
             ? null
             : await acquireDaemonInstallationLease(installation.npmPrefix);
+        const storageRuntime = values.profile === undefined
+            ? null
+            : await loadStorageRuntime({
+                profile: values.profile,
+                serverUrl: config.serverUrl,
+                userHome: homedir(),
+                platform: process.platform,
+                environment: process.env,
+            });
+        const migrationRuntime = values.profile === undefined || activeDaemonHome === undefined || storageRuntime !== null
+            ? { ready: false, reason: "not_legacy_source" }
+            : await probeStorageMigrationRuntime({
+                profile: values.profile,
+                serverUrl: config.serverUrl,
+                currentDaemonHome: activeDaemonHome,
+                currentAgentsRoot: config.agentsRoot,
+                userHome: homedir(),
+                platform: process.platform,
+                ...(process.getuid === undefined ? {} : { uid: process.getuid() }),
+                environment: process.env,
+            });
+        const targetConfirmation = storageRuntime?.identity.storageMigrationId === undefined
+            ? null
+            : createStorageTargetConfirmationHandler({
+                backupsRoot: storageRuntime.local.backupsRoot,
+                identity: storageRuntime.identity,
+                profile: storageRuntime.installation.profile,
+                completionTimeoutMs: 180_000,
+            });
+        const storageMigration = storageRuntime !== null
+            ? {
+                ready: false,
+                statusOutboxPath: join(storageRuntime.local.stateRoot, "storage-status-outbox.json"),
+                identity: storageRuntime.identity,
+                ...(targetConfirmation === null ? {} : { confirm: targetConfirmation.handle }),
+                ...(storageRuntime.identity.storageMigrationId === undefined ? {} : {
+                    replayStatus: async (send) => {
+                        const migrationId = storageRuntime.identity.storageMigrationId;
+                        const receipt = await readStorageMigrationReceipt(storageRuntime.local.backupsRoot, migrationId);
+                        if (receipt === null)
+                            throw new Error(`storage migration receipt not found: ${migrationId}`);
+                        for (const frame of storageMigrationStatusReplay(receipt, {
+                            migrationId,
+                            environment: storageRuntime.identity.storageEnvironment,
+                            workspaceId: storageRuntime.identity.storageWorkspaceId,
+                            profile: storageRuntime.installation.profile,
+                        }))
+                            send(frame);
+                    },
+                }),
+            }
+            : migrationRuntime.ready
+                ? {
+                    ready: true,
+                    statusOutboxPath: migrationRuntime.runtime.statusOutboxPath,
+                    identity: migrationRuntime.runtime.identity,
+                    controller: migrationRuntime.runtime.controller,
+                    attach: migrationRuntime.runtime.attach,
+                    bindServerIdentity: migrationRuntime.runtime.bindServerIdentity,
+                    replayStatus: migrationRuntime.runtime.replayStatus,
+                }
+                : undefined;
         await runWithDaemonInstallationLease(installationLease, async () => {
             const service = serve(config, {
                 ...(values.profile === undefined ? {} : { profileName: values.profile }),
+                ...(storageMigration === undefined ? {} : { storageMigration }),
             });
             await runServeLifecycle(service);
         });

package/dist/managed-service-lifecycle.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { acquireDaemonInstallationLease } from "./daemon-installation-lease.js";
-import { installService, ensureServiceEnabled, readServiceDescriptor, serviceAction, uninstallService, } from "./computer-service.js";
+import { installService, ensureServiceEnabled, readServiceDescriptor, serviceAction, replaceInstalledServiceDescriptor, uninstallService, } from "./computer-service.js";
 import { ManagedServiceConflictError, ManagedServiceRegistryError, assertRegistryCoversDescriptors, listManagedServiceDescriptorPaths, managedServiceIdentityMatches, managedServiceConflict, normalizeManagedServiceRecord, serviceDescriptorSha256, withManagedServiceRegistryLock, } from "./managed-service-registry.js";
 function requirePortableManagedSpec(spec) {
     if ((spec.platform !== "darwin" && spec.platform !== "linux")
@@ -35,6 +35,17 @@ function sameManagedIdentity(left, right) {
     const { generation: _generation, createdAt: _createdAt, ...expected } = right;
     return managedServiceIdentityMatches(left, expected);
 }
+function sameManagedResource(left, right) {
+    const { generation: _leftGeneration, createdAt: _leftCreatedAt, descriptorSha256: _leftHash, ...leftResource } = left;
+    const { generation: _rightGeneration, createdAt: _rightCreatedAt, descriptorSha256: _rightHash, ...rightResource } = right;
+    return JSON.stringify(leftResource) === JSON.stringify(rightResource);
+}
+function descriptorDiffIsStorageEnvironmentOnly(previous, next) {
+    if (!next.includes("\n  <key>EnvironmentVariables</key>\n"))
+        return false;
+    const strip = (descriptor) => descriptor.replace(/\n  <key>EnvironmentVariables<\/key>\n  <dict>\n(?:    <key>(?:NOWWORK_HOME|NOWWORK_ENV_TAG|NOWWORK_STORAGE_POLICY_PATH)<\/key><string>[^<]*<\/string>\n)+  <\/dict>\n/u, "\n");
+    return strip(previous) === strip(next);
+}
 function assertRecordDescribesSpec(input) {
     requirePortableManagedSpec(input.spec);
     const { spec, record } = input;
@@ -51,8 +62,20 @@ function assertRecordDescribesSpec(input) {
     }
 }
 export async function installManagedService(input) {
-    assertRecordDescribesSpec(input);
     requirePortableManagedSpec(input.spec);
+    const requestedDescriptor = input.spec.descriptor;
+    const expectedDescriptorHash = serviceDescriptorSha256(input.spec.descriptor);
+    const expectedPath = normalizeManagedServiceRecord({
+        ...input.record,
+        descriptorPath: input.spec.descriptorPath,
+        descriptorSha256: expectedDescriptorHash,
+    }).descriptorPath;
+    if (input.record.platform !== input.spec.platform
+        || input.record.serviceId !== input.spec.id
+        || input.record.profile !== input.spec.profile
+        || input.record.descriptorPath !== expectedPath) {
+        throw new ManagedServiceRegistryError(`Managed service record does not describe '${input.spec.id}'`);
+    }
     const acquire = input.acquireInstallationLease ?? acquireDaemonInstallationLease;
     await withManagedServiceRegistryLock(input.registry ?? {}, async ({ services, replace }) => {
         const exact = services.find((record) => sameManagedIdentity(record, input.record));
@@ -76,6 +99,28 @@ export async function installManagedService(input) {
             }
             return;
         }
+        const registered = services.find((record) => record.serviceId === input.record.serviceId
+            && record.profile === input.record.profile
+            && record.daemonHome === input.record.daemonHome);
+        if (registered !== undefined && sameManagedResource(registered, input.record)) {
+            const current = await readServiceDescriptor(input.spec);
+            if (current === null || serviceDescriptorSha256(current) !== registered.descriptorSha256) {
+                throw new ManagedServiceRegistryError(`Installed descriptor for '${input.spec.id}' does not match its registry record`);
+            }
+            if (!descriptorDiffIsStorageEnvironmentOnly(current, requestedDescriptor)) {
+                throw new ManagedServiceRegistryError(`Installed descriptor for '${input.spec.id}' conflicts with the requested identity`);
+            }
+            await replaceInstalledServiceDescriptor(input.spec, current, input.runner);
+            try {
+                await replace(services.map((record) => record === registered ? input.record : record));
+            }
+            catch (error) {
+                const rollbackSpec = { ...input.spec, descriptor: current };
+                await replaceInstalledServiceDescriptor(rollbackSpec, requestedDescriptor, input.runner).catch(() => undefined);
+                throw error;
+            }
+            return;
+        }
         const conflict = managedServiceConflict(services, input.record);
         if (conflict !== null) {
             throw new ManagedServiceConflictError(conflict.resource, input.record, conflict.owner);