@nowcrew/daemon 0.6.58 → 0.6.63

package/dist/local-memory/write.js

@@ -1,448 +0,0 @@
-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/storage-config.js

@@ -1,175 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { posix, win32 } from "node:path";
-import { z } from "zod";
-import { atomicPrivateWrite } from "./atomic-private-write.js";
-import { resolveEnvTag, resolveNowworkHome, storageLayout, } from "./storage-layout.js";
-const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-const PROFILE = /^[a-z0-9][a-z0-9_-]{0,47}$/u;
-const PORTABLE_ABSOLUTE_PATH = z.string().min(1).max(32768).refine((value) => posix.isAbsolute(value) || win32.isAbsolute(value), "must be an absolute path");
-const ServerUrlSchema = z.string().url().max(2048).refine((value) => {
-    const url = new URL(value);
-    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password;
-}, "serverUrl must be HTTP(S) without embedded credentials");
-const InstallationRecordSchema = z.object({
-    version: z.literal(1),
-    installationId: z.string().uuid(),
-    profile: z.string().regex(PROFILE),
-    serverUrl: ServerUrlSchema,
-    environment: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,31}$/u),
-    workspaceId: z.string().uuid(),
-    storageId: z.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u),
-    nowworkHome: PORTABLE_ABSOLUTE_PATH,
-    runtimeRoot: PORTABLE_ABSOLUTE_PATH,
-    credentialRef: z.string().regex(/^profile:[a-z0-9][a-z0-9_-]{0,47}$/u),
-    storageMigrationId: z.string().uuid().optional(),
-    createdAt: z.string().datetime({ offset: true }),
-    updatedAt: z.string().datetime({ offset: true }),
-}).strict();
-const InstallationRegistrySchema = z.object({
-    version: z.literal(1),
-    installations: z.array(InstallationRecordSchema).max(256),
-}).strict();
-export function findInstallationForProfile(records, profile) {
-    if (!PROFILE.test(profile))
-        throw new Error("profile name is invalid");
-    const matches = records.filter((record) => record.profile === profile);
-    if (matches.length > 1)
-        throw new Error(`Multiple installations use profile '${profile}'`);
-    return matches[0] ?? null;
-}
-const pathsFor = (platform) => platform === "win32" ? win32 : posix;
-function absoluteBase(value, fallback, platform, name) {
-    const paths = pathsFor(platform);
-    const selected = value ?? fallback;
-    if (!paths.isAbsolute(selected) || selected.includes("\0") || selected.includes("\n") || selected.includes("\r")) {
-        throw new Error(`${name} must be an absolute single-line path`);
-    }
-    return paths.normalize(selected);
-}
-export function resolveLocalStorageRoots(input) {
-    const paths = pathsFor(input.platform);
-    const userHome = absoluteBase(input.userHome, input.userHome, input.platform, "user home");
-    if (input.platform === "win32") {
-        const local = absoluteBase(input.environment.LOCALAPPDATA, paths.join(userHome, "AppData", "Local"), input.platform, "LOCALAPPDATA");
-        const root = paths.join(local, "NowWork");
-        return Object.freeze({
-            configRoot: paths.join(root, "config"),
-            runtimeBase: paths.join(root, "runtime"),
-            cacheRoot: paths.join(root, "cache"),
-            stateRoot: paths.join(root, "state"),
-            backupsRoot: paths.join(root, "state", "backups"),
-            runtimePackagesRoot: paths.join(root, "cache", "runtime-packages"),
-        });
-    }
-    if (input.platform === "darwin") {
-        const applicationSupport = paths.join(userHome, "Library", "Application Support", "NowWork");
-        const cacheRoot = paths.join(userHome, "Library", "Caches", "NowWork");
-        return Object.freeze({
-            configRoot: paths.join(applicationSupport, "config"),
-            runtimeBase: paths.join(cacheRoot, "runtime"),
-            cacheRoot,
-            stateRoot: paths.join(applicationSupport, "state"),
-            backupsRoot: paths.join(applicationSupport, "state", "backups"),
-            runtimePackagesRoot: paths.join(cacheRoot, "runtime-packages"),
-        });
-    }
-    const configHome = absoluteBase(input.environment.XDG_CONFIG_HOME, paths.join(userHome, ".config"), input.platform, "XDG_CONFIG_HOME");
-    const cacheHome = absoluteBase(input.environment.XDG_CACHE_HOME, paths.join(userHome, ".cache"), input.platform, "XDG_CACHE_HOME");
-    const stateHome = absoluteBase(input.environment.XDG_STATE_HOME, paths.join(userHome, ".local", "state"), input.platform, "XDG_STATE_HOME");
-    const runtimeHome = absoluteBase(input.environment.XDG_RUNTIME_DIR, paths.join(stateHome, "nowwork", "runtime"), input.platform, "XDG_RUNTIME_DIR");
-    const stateRoot = paths.join(stateHome, "nowwork");
-    const cacheRoot = paths.join(cacheHome, "nowwork");
-    return Object.freeze({
-        configRoot: paths.join(configHome, "nowwork"),
-        runtimeBase: input.environment.XDG_RUNTIME_DIR === undefined ? runtimeHome : paths.join(runtimeHome, "nowwork"),
-        cacheRoot,
-        stateRoot,
-        backupsRoot: paths.join(stateRoot, "backups"),
-        runtimePackagesRoot: paths.join(cacheRoot, "runtime-packages"),
-    });
-}
-export function buildStorageConfig(input) {
-    if (!PROFILE.test(input.profile))
-        throw new Error("profile name is invalid");
-    if (!UUID.test(input.workspaceId))
-        throw new Error("workspace id must be a UUID");
-    const paths = pathsFor(input.platform);
-    const local = resolveLocalStorageRoots(input);
-    const home = resolveNowworkHome({
-        ...(input.nowworkHome === undefined ? {} : { explicit: input.nowworkHome }),
-        ...(input.environment.NOWWORK_HOME === undefined ? {} : { environment: input.environment.NOWWORK_HOME }),
-        userHome: input.userHome,
-        platform: input.platform,
-    });
-    const credentialRef = `profile:${input.profile}`;
-    if (home.mode === "legacy") {
-        return Object.freeze({
-            mode: "legacy",
-            profile: input.profile,
-            workspaceId: input.workspaceId.toLowerCase(),
-            credentialRef,
-            daemonHome: input.legacyDaemonHome ?? paths.join(input.userHome, ".crew", "daemon"),
-            agentsRoot: input.legacyAgentsRoot ?? paths.join(input.userHome, ".crew", "agents"),
-            layout: null,
-            local,
-            diagnostics: Object.freeze(["legacy_storage_detected"]),
-        });
-    }
-    const environment = resolveEnvTag({
-        ...(input.envTag === undefined ? {} : { explicit: input.envTag }),
-        ...(input.environment.NOWWORK_ENV_TAG === undefined ? {} : { environment: input.environment.NOWWORK_ENV_TAG }),
-    }).environment;
-    const layout = storageLayout({
-        nowworkHome: home.root,
-        environment,
-        workspaceId: input.workspaceId,
-        runtimeBase: local.runtimeBase,
-        platform: input.platform,
-    });
-    return Object.freeze({
-        mode: "standard",
-        profile: input.profile,
-        workspaceId: input.workspaceId.toLowerCase(),
-        credentialRef,
-        daemonHome: local.configRoot,
-        agentsRoot: layout.agentItemsRoot,
-        layout,
-        local,
-        diagnostics: Object.freeze([]),
-    });
-}
-export function installationsPath(configRoot) {
-    const paths = win32.isAbsolute(configRoot) && !posix.isAbsolute(configRoot) ? win32 : posix;
-    return paths.join(configRoot, "installations.json");
-}
-export async function readInstallations(input) {
-    const path = installationsPath(input.configRoot);
-    try {
-        const parsed = InstallationRegistrySchema.parse(JSON.parse(await readFile(path, "utf8")));
-        return Object.freeze(parsed.installations.map((record) => Object.freeze(record)));
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return Object.freeze([]);
-        throw new Error(`Invalid installation registry: ${path}`, { cause: error });
-    }
-}
-export async function writeInstallations(records, input) {
-    let parsed;
-    try {
-        parsed = InstallationRegistrySchema.parse({ version: 1, installations: records });
-        const installationIds = new Set();
-        const profiles = new Set();
-        for (const record of parsed.installations) {
-            if (installationIds.has(record.installationId) || profiles.has(record.profile)) {
-                throw new Error("duplicate installation identity");
-            }
-            installationIds.add(record.installationId);
-            profiles.add(record.profile);
-        }
-    }
-    catch (error) {
-        throw new Error("Invalid installation metadata", { cause: error });
-    }
-    await atomicPrivateWrite(installationsPath(input.configRoot), `${JSON.stringify(parsed, null, 2)}\n`);
-}