@exla/rudder 0.0.0-stage → 3.4.0

package/dist/state.js

@@ -0,0 +1,704 @@
+import path from "node:path";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import { DEFAULT_BOARD_PORT } from "./types.js";
+import { ensureDir, newRunId, nowIso, readJson, rudderHome, runCommand, shortHash, slugPrefix, slugify, updateJson, writeJson, } from "./util.js";
+import { llmSummarizeTask, summarizeTask } from "./task-summary.js";
+const OUTPUT_TXT_MAX_BYTES = 2 * 1024 * 1024;
+export function globalConfigPath() {
+    return path.join(rudderHome(), "config.json");
+}
+export function projectsRegistryPath() {
+    return path.join(rudderHome(), "projects.json");
+}
+let lastUsedCodexModelCache = null;
+// The model the user last picked for codex (`backends.codex.model`, saved by
+// every /model choice). Synchronous so the sync arg-builders can consult it
+// before falling back to a hardcoded model: "the default is the last used
+// model", not whatever release was current when this file last shipped.
+// Cached for the life of the process — the CLI is short-lived, and a mid-run
+// /model change updates the run record itself, not these fallbacks.
+/** Codex's default model. gpt-5.5 retired on 2026-10-14; Codex then shows a
+ * blocking "Try new model" dialog in every session launched on it. Mirrors
+ * `CODEX_DEFAULT_MODEL` in native/src/models.rs. */
+export const CODEX_DEFAULT_MODEL = "gpt-6.1-sol";
+const RETIRED_CODEX_MODELS = new Set(["gpt-5.5", "gpt-5.5-pro"]);
+export function liveCodexModel(model) {
+    return model && RETIRED_CODEX_MODELS.has(model.trim()) ? CODEX_DEFAULT_MODEL : model;
+}
+export function lastUsedCodexModelSync() {
+    if (lastUsedCodexModelCache === null) {
+        let model;
+        try {
+            const raw = fs.readFileSync(globalConfigPath(), "utf8");
+            const parsed = JSON.parse(raw);
+            const value = parsed?.backends?.codex?.model;
+            model = typeof value === "string" && value.trim() ? liveCodexModel(value.trim()) : undefined;
+        }
+        catch {
+            model = undefined;
+        }
+        lastUsedCodexModelCache = model;
+    }
+    return lastUsedCodexModelCache;
+}
+export function authStorePath() {
+    return path.join(rudderHome(), "auth-profiles.json");
+}
+export function cloudAuthPath() {
+    return path.join(rudderHome(), "cloud.json");
+}
+export function projectStateDir(repoRoot) {
+    return path.join(repoRoot, ".rudder");
+}
+/**
+ * Directory INSIDE the repo holding one jj workspace per agent. Named for what
+ * it holds: `jj workspace add` targets, not git worktrees.
+ */
+export const AGENT_WORKSPACES_DIR = ".rudder-workspaces";
+/**
+ * The pre-rename name for the same directory. Still recognized everywhere a path
+ * is CLASSIFIED (ignore rules, path healing, gc scans, dashboard-root walks): a
+ * jj workspace is registered in `.jj` under the absolute path it was created at,
+ * so workspaces made before the rename must keep resolving. Only NEW workspaces
+ * are created under AGENT_WORKSPACES_DIR.
+ */
+export const LEGACY_AGENT_WORKSPACES_DIR = ".rudder-worktrees";
+const PROJECT_RUNTIME_IGNORES = [
+    ".rudder/",
+    `${AGENT_WORKSPACES_DIR}/`,
+    `${LEGACY_AGENT_WORKSPACES_DIR}/`,
+    "RUDDER.md",
+    "RUDDER_SHARED.md",
+];
+const projectRuntimeIgnoreInstalls = new Map();
+/**
+ * Keep Rudder's live control plane out of every jj snapshot. This must run
+ * before creating scaffold changes or workspaces: adding the ignores after a
+ * workspace command is too late because jj snapshots the current checkout as
+ * part of that command.
+ *
+ * We write both .gitignore (the existing, visible project contract) and Git's
+ * local exclude file. The latter applies immediately across colocated jj
+ * workspaces, including a scaffold change created before an older Rudder
+ * version had installed the project-level rules.
+ */
+export function ensureProjectRuntimeIgnored(repoRoot) {
+    const key = path.resolve(repoRoot);
+    const existing = projectRuntimeIgnoreInstalls.get(key);
+    if (existing)
+        return existing;
+    const install = installProjectRuntimeIgnores(key).catch((error) => {
+        projectRuntimeIgnoreInstalls.delete(key);
+        throw error;
+    });
+    projectRuntimeIgnoreInstalls.set(key, install);
+    return install;
+}
+async function installProjectRuntimeIgnores(repoRoot) {
+    const targets = [path.join(repoRoot, ".gitignore")];
+    const exclude = await runCommand("git", ["rev-parse", "--git-path", "info/exclude"], {
+        cwd: repoRoot,
+        allowFailure: true,
+    }).catch(() => null);
+    const excludePath = exclude?.stdout.trim();
+    if (excludePath) {
+        targets.push(path.isAbsolute(excludePath) ? excludePath : path.resolve(repoRoot, excludePath));
+    }
+    for (const target of new Set(targets)) {
+        for (const line of PROJECT_RUNTIME_IGNORES) {
+            await ensureIgnoreLine(target, line);
+        }
+    }
+}
+async function ensureIgnoreLine(filePath, line) {
+    const existing = await fsp.readFile(filePath, "utf8").catch(() => "");
+    if (existing.split(/\r?\n/).some((item) => item.trim() === line)) {
+        return;
+    }
+    const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+    await ensureDir(path.dirname(filePath));
+    await fsp.appendFile(filePath, `${prefix}${line}\n`, "utf8");
+}
+export function runsDir(repoRoot) {
+    return path.join(projectStateDir(repoRoot), "runs");
+}
+export function undoStackPath(repoRoot) {
+    return path.join(projectStateDir(repoRoot), "undo-stack.json");
+}
+export function runDir(repoRoot, runId) {
+    return path.join(runsDir(repoRoot), runId);
+}
+export function runRecordPath(repoRoot, runId) {
+    return path.join(runDir(repoRoot, runId), "run.json");
+}
+export function eventsPath(repoRoot, runId) {
+    return path.join(runDir(repoRoot, runId), "events.ndjson");
+}
+export function outputPath(repoRoot, runId) {
+    return path.join(runDir(repoRoot, runId), "output.txt");
+}
+export function stopRequestPath(repoRoot, runId) {
+    return path.join(runDir(repoRoot, runId), "stop-request.json");
+}
+export function agentContextPath(repoRoot) {
+    return path.join(repoRoot, "RUDDER.md");
+}
+export function specPath(repoRoot, runId) {
+    return path.join(runDir(repoRoot, runId), "spec.json");
+}
+export function verifierPath(repoRoot, runId) {
+    return path.join(runDir(repoRoot, runId), "verifier.json");
+}
+export function workspacePath(repoRoot, runId, task) {
+    // Workspaces live INSIDE the project (gitignored .rudder-workspaces/), not in the parent
+    // directory. This keeps every Rudder path within the project boundary, so a planner or
+    // agent confined to the project never reads outside it — which is what triggered
+    // Claude's "allow reading outside the project?" permission prompt.
+    const repoName = `${slugify(path.basename(repoRoot), "repo")}-${shortHash(repoRoot)}`;
+    return path.join(repoRoot, AGENT_WORKSPACES_DIR, repoName, workspaceDirName(runId, task));
+}
+function workspaceDirName(runId, task) {
+    const slug = slugPrefix(task ?? runId, "task");
+    const suffix = shortHash(runId).slice(0, 8);
+    return `${slug}-${suffix}`;
+}
+export async function loadConfig() {
+    const existing = await readJson(globalConfigPath());
+    if (existing?.version === 1) {
+        return normalizeConfig(existing);
+    }
+    return defaultConfig();
+}
+export function defaultConfig() {
+    return {
+        version: 1,
+        defaultBackend: "claude",
+        mergeStrategy: "merge",
+        colorMode: "terminal",
+        runPolicy: {
+            sameCheckout: "single-active",
+            concurrentPromptMode: "workspace",
+        },
+        acpx: { install: "latest" },
+        backends: {
+            claude: { profileId: "anthropic:claude-code", model: "sonnet" },
+            codex: {
+                profileId: "openai-codex:default",
+                model: CODEX_DEFAULT_MODEL,
+            },
+            acpx: { model: CODEX_DEFAULT_MODEL },
+        },
+        board: { port: DEFAULT_BOARD_PORT },
+        orchestrator: { maxParallel: 1000 },
+    };
+}
+function normalizeConfig(existing) {
+    const defaults = defaultConfig();
+    const normalized = {
+        ...defaults,
+        ...existing,
+        mergeStrategy: parseMergeStrategy(existing.mergeStrategy),
+        colorMode: existing.colorMode === "paper" ? "paper" : "terminal",
+        runPolicy: {
+            ...defaults.runPolicy,
+            ...(existing.runPolicy ?? {}),
+        },
+        acpx: {
+            ...defaults.acpx,
+            ...(existing.acpx ?? {}),
+        },
+        backends: {
+            ...defaults.backends,
+            ...(existing.backends ?? {}),
+        },
+        board: {
+            ...defaults.board,
+            ...(existing.board ?? {}),
+        },
+        orchestrator: {
+            maxParallel: existing.orchestrator?.maxParallel ?? defaults.orchestrator?.maxParallel ?? 1000,
+            ...(existing.orchestrator?.budget ? { budget: existing.orchestrator.budget } : {}),
+        },
+    };
+    for (const id of ["codex", "acpx"]) {
+        const backend = normalized.backends[id];
+        if (backend?.model)
+            backend.model = liveCodexModel(backend.model);
+    }
+    // Remove the retired merge gate instead of carrying a dead feature flag
+    // forward through the top-level config spread.
+    Reflect.deleteProperty(normalized, "autoMerge");
+    return normalized;
+}
+function parseMergeStrategy(value) {
+    return value === "rebase" ? "rebase" : "merge";
+}
+export async function saveConfig(config) {
+    await writeJson(globalConfigPath(), config, { mode: 0o600 });
+}
+export async function rememberBackendSelection(params) {
+    const config = await loadConfig();
+    applyBackendSelection(config, params);
+    await saveConfig(config);
+    return config;
+}
+function applyBackendSelection(config, params) {
+    config.lastUsedBackend = params.backend;
+    config.backends = config.backends ?? {};
+    if (!params.updateModel && !params.updateEffort) {
+        return;
+    }
+    const next = { ...(config.backends[params.backend] ?? {}) };
+    if (params.updateModel) {
+        if (params.model) {
+            next.model = params.model;
+        }
+        else {
+            delete next.model;
+        }
+    }
+    if (params.updateEffort) {
+        if (params.backend === "claude") {
+            if (params.effort) {
+                next.effort = params.effort;
+            }
+            else {
+                delete next.effort;
+            }
+        }
+        else if (params.effort) {
+            next.reasoningEffort = params.effort;
+        }
+        else {
+            delete next.reasoningEffort;
+        }
+    }
+    config.backends[params.backend] = next;
+}
+export async function loadAuthStore() {
+    const existing = await readJson(authStorePath());
+    if (existing?.version === 1 && existing.profiles && typeof existing.profiles === "object") {
+        return {
+            version: 1,
+            profiles: normalizeProfiles(existing.profiles),
+            order: existing.order,
+            lastGood: existing.lastGood,
+            usageStats: existing.usageStats,
+        };
+    }
+    return { version: 1, profiles: {} };
+}
+function normalizeProfiles(profiles) {
+    const normalized = {};
+    for (const [profileId, raw] of Object.entries(profiles)) {
+        if (!raw || typeof raw !== "object") {
+            continue;
+        }
+        const entry = { ...raw };
+        if (!entry.type && typeof entry.mode === "string") {
+            entry.type = entry.mode;
+        }
+        if (entry.type === "api_key" && typeof entry.provider === "string") {
+            normalized[profileId] = {
+                type: "api_key",
+                provider: entry.provider,
+                ...(typeof entry.key === "string" ? { key: entry.key } : {}),
+                ...(typeof entry.apiKey === "string" ? { key: entry.apiKey } : {}),
+            };
+            continue;
+        }
+        if (entry.type === "token" && typeof entry.provider === "string") {
+            normalized[profileId] = {
+                type: "token",
+                provider: entry.provider,
+                ...(typeof entry.token === "string" ? { token: entry.token } : {}),
+                ...(typeof entry.expires === "number" ? { expires: entry.expires } : {}),
+            };
+            continue;
+        }
+        if (entry.type === "oauth" &&
+            typeof entry.provider === "string" &&
+            typeof entry.access === "string" &&
+            typeof entry.refresh === "string" &&
+            typeof entry.expires === "number") {
+            normalized[profileId] = {
+                type: "oauth",
+                provider: entry.provider,
+                access: entry.access,
+                refresh: entry.refresh,
+                expires: entry.expires,
+                ...(typeof entry.email === "string" ? { email: entry.email } : {}),
+                ...(typeof entry.accountId === "string" ? { accountId: entry.accountId } : {}),
+            };
+        }
+    }
+    return normalized;
+}
+export async function saveAuthStore(store) {
+    await writeJson(authStorePath(), store, { mode: 0o600 });
+}
+export async function createRunRecord(params) {
+    const id = params.id ?? newRunId(params.task);
+    const createdAt = nowIso();
+    const record = {
+        id,
+        status: "created",
+        vcs: params.vcs,
+        ...(params.resolverFor ? { resolverFor: params.resolverFor } : {}),
+        mode: params.mode ?? "execute",
+        task: params.task,
+        taskSummary: summarizeTask(params.task),
+        backend: params.backend,
+        model: params.model,
+        effort: params.effort,
+        createdAt,
+        updatedAt: createdAt,
+        repoRoot: params.repoRoot,
+        targetBranch: params.targetBranch,
+        baseCommit: params.baseCommit,
+        workspace: {
+            enabled: params.useWorkspace,
+            path: params.workspacePath ?? params.repoRoot,
+            branch: params.workspaceBranch,
+            workspaceName: params.workspaceName,
+            ...(params.workspaceChangeId ? { jjChangeId: params.workspaceChangeId } : {}),
+        },
+        currentPrompt: params.task,
+        turns: [{ ts: createdAt, prompt: params.task, source: "user" }],
+        lastUserInputAt: createdAt,
+        autoSteer: { count: 0, max: 2 },
+    };
+    await ensureDir(runDir(params.repoRoot, id));
+    await saveRunRecord(record);
+    return record;
+}
+export async function saveRunRecord(record, options) {
+    record.taskSummary = record.taskSummary || summarizeTask(record.task);
+    record.updatedAt = nowIso();
+    let saved = false;
+    await updateJson(runRecordPath(record.repoRoot, record.id), (prev) => {
+        // A redirected headless run starts a fresh attempt. Backend/controller
+        // callbacks from the superseded process may still arrive briefly after the
+        // signal; keep those stale snapshots from overwriting the new turn.
+        if (options?.expectedAttemptId &&
+            prev &&
+            prev.process?.attemptId !== options.expectedAttemptId) {
+            return prev;
+        }
+        // Runs created by an older Rudder have no attempt id. Their worker still
+        // carries the original startedAt, so use it as a migration-safe ownership
+        // token and reject it once a redirect installs a new attempt.
+        if (!options?.expectedAttemptId &&
+            options?.expectedStartedAt &&
+            prev &&
+            (Boolean(prev.process?.attemptId) || prev.process?.startedAt !== options.expectedStartedAt)) {
+            return prev;
+        }
+        // A long-lived in-memory `record` can be stale: the background LLM
+        // summarizer reads + rewrites run.json out of band. Preserve the title it
+        // persisted instead of clobbering it with the naive summary.
+        if (prev?.taskSummaryLlm && !record.taskSummaryLlm) {
+            record.taskSummary = prev.taskSummary;
+            record.taskSummaryLlm = true;
+        }
+        saved = true;
+        return record;
+    });
+    return saved;
+}
+const inflightLlmSummaries = new Set();
+/**
+ * Records written before the worktree->workspace rename carry the isolation info
+ * under a `worktree` key. Lift it onto `workspace` on read so every consumer
+ * speaks one name; the next save persists the new key. Reading a record must
+ * never throw on the old shape, so this is a pure in-memory promotion.
+ */
+export function adoptLegacyWorkspaceKey(record) {
+    const raw = record;
+    if (raw.workspace === undefined && raw.worktree !== undefined) {
+        raw.workspace = raw.worktree;
+    }
+    delete raw.worktree;
+    return record;
+}
+export async function loadRunRecord(repoRoot, runId) {
+    const record = await readJson(runRecordPath(repoRoot, runId));
+    if (record) {
+        adoptLegacyWorkspaceKey(record);
+        healMovedRepoPaths(record, repoRoot);
+    }
+    if (record && !record.taskSummary) {
+        record.taskSummary = summarizeTask(record.task);
+    }
+    if (record) {
+        maybeBackgroundLlmSummarize(record);
+    }
+    return record;
+}
+/**
+ * Recorded absolute paths survive a repo RENAME or MOVE; the repo does not.
+ * Everything a run record points at (workspaces, cwds) lives INSIDE the repo
+ * and moves with it, so when the record's repoRoot disagrees with the root we
+ * are actually reading it from, every stored path under the old root has an
+ * exact counterpart under the new one. Rewrite the prefix and the record is
+ * true again — the same reason jj survives a rename: its workspace pointers
+ * are relative. In-memory only; the healed record persists whenever the
+ * record is next saved.
+ */
+export function healMovedRepoPaths(record, actualRepoRoot) {
+    const currentRoot = path.resolve(actualRepoRoot);
+    // Rule 1's key: the stored root, IF it disagrees. Rule 2 exists because
+    // rule 1 is not enough — a later save can rewrite repoRoot alone (observed:
+    // repoRoot said the new name while workspace.path still said the old one).
+    // Workspaces always live at <root>/<agent-workspaces-dir>/..., so whatever
+    // precedes that marker is some spelling of the root; rebase it.
+    const storedRoot = record.repoRoot && record.repoRoot !== currentRoot ? record.repoRoot : null;
+    const markers = [
+        `${path.sep}${AGENT_WORKSPACES_DIR}${path.sep}`,
+        `${path.sep}${LEGACY_AGENT_WORKSPACES_DIR}${path.sep}`,
+    ];
+    const remap = (value) => {
+        if (typeof value === "string") {
+            if (storedRoot) {
+                if (value === storedRoot)
+                    return currentRoot;
+                if (value.startsWith(storedRoot + path.sep)) {
+                    return currentRoot + value.slice(storedRoot.length);
+                }
+            }
+            for (const marker of markers) {
+                const index = value.indexOf(marker);
+                if (index >= 0 && !value.startsWith(currentRoot)) {
+                    return currentRoot + value.slice(index);
+                }
+            }
+            return value;
+        }
+        if (Array.isArray(value)) {
+            for (let i = 0; i < value.length; i += 1)
+                value[i] = remap(value[i]);
+            return value;
+        }
+        if (value && typeof value === "object") {
+            const obj = value;
+            for (const key of Object.keys(obj))
+                obj[key] = remap(obj[key]);
+            return value;
+        }
+        return value;
+    };
+    remap(record);
+    // A record inside <root>/.rudder/runs belongs to <root> by construction.
+    record.repoRoot = currentRoot;
+}
+/**
+ * Scan every run record in the repo and fire a background LLM summarization
+ * for any whose task summary has never been upgraded. Used by the CLI before
+ * spawning the native dashboard so the next launch picks up nicer titles even
+ * though the native dashboard reads run.json directly and skips the TS load
+ * path. Caps the number of in-flight summaries so a big repo doesn't blast
+ * Anthropic. Never throws.
+ */
+export async function backfillLlmTaskSummaries(repoRoot, maxInFlight = 8) {
+    try {
+        const dir = runsDir(repoRoot);
+        const entries = await fsp.readdir(dir, { withFileTypes: true });
+        const ids = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+        const slice = ids.slice(0, maxInFlight);
+        for (const id of slice) {
+            const record = await readJson(runRecordPath(repoRoot, id));
+            if (record) {
+                maybeBackgroundLlmSummarize(record);
+            }
+        }
+    }
+    catch {
+        // ignore — best-effort
+    }
+}
+function maybeBackgroundLlmSummarize(record) {
+    if (record.taskSummaryLlm) {
+        return;
+    }
+    const task = (record.task ?? "").trim();
+    if (!task) {
+        return;
+    }
+    const naive = summarizeTask(record.task);
+    const current = (record.taskSummary ?? "").trim();
+    if (current && current !== naive) {
+        // user (or some other path) already set a non-naive title; skip
+        return;
+    }
+    const key = `${record.repoRoot}::${record.id}`;
+    if (inflightLlmSummaries.has(key)) {
+        return;
+    }
+    inflightLlmSummaries.add(key);
+    (async () => {
+        try {
+            const title = await llmSummarizeTask(record.task);
+            if (!title) {
+                return;
+            }
+            const file = runRecordPath(record.repoRoot, record.id);
+            await updateJson(file, (fresh) => {
+                if (!fresh)
+                    return undefined;
+                if (fresh.taskSummaryLlm)
+                    return fresh;
+                const currentNaive = summarizeTask(fresh.task);
+                const currentTitle = (fresh.taskSummary ?? "").trim();
+                if (currentTitle && currentTitle !== currentNaive) {
+                    return fresh;
+                }
+                // Merge only the summary fields into the record read under the
+                // cross-process lock. Never rewrite status/turn/process ownership from
+                // the stale snapshot that initiated the LLM request.
+                fresh.taskSummary = title;
+                fresh.taskSummaryLlm = true;
+                fresh.updatedAt = nowIso();
+                return fresh;
+            });
+        }
+        catch {
+            // swallow — background best-effort
+        }
+        finally {
+            inflightLlmSummaries.delete(key);
+        }
+    })();
+}
+export async function appendEvent(repoRoot, event) {
+    await ensureDir(runDir(repoRoot, event.runId));
+    await fsp.appendFile(eventsPath(repoRoot, event.runId), `${JSON.stringify(event)}\n`, "utf8");
+    const text = event.type === "backend.output" || event.type === "backend.error"
+        ? event.message ?? (typeof event.data === "string" ? event.data : undefined)
+        : undefined;
+    if (text) {
+        const file = outputPath(repoRoot, event.runId);
+        await fsp.appendFile(file, text, "utf8");
+        await trimFileTail(file, OUTPUT_TXT_MAX_BYTES);
+    }
+}
+async function trimFileTail(file, maxBytes) {
+    const stat = await fsp.stat(file).catch(() => null);
+    if (!stat || stat.size <= maxBytes) {
+        return;
+    }
+    const keep = Math.max(1, maxBytes);
+    const handle = await fsp.open(file, "r").catch(() => null);
+    if (!handle) {
+        return;
+    }
+    try {
+        const buffer = Buffer.alloc(keep);
+        await handle.read(buffer, 0, keep, Math.max(0, stat.size - keep));
+        const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+        await fsp.writeFile(temp, buffer);
+        await fsp.rename(temp, file);
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+export async function listRuns(repoRoot) {
+    await ensureDir(runsDir(repoRoot));
+    const entries = await fsp.readdir(runsDir(repoRoot), { withFileTypes: true });
+    const runs = await Promise.all(entries
+        .filter((entry) => entry.isDirectory())
+        .map(async (entry) => await loadRunRecord(repoRoot, entry.name)));
+    return runs
+        .filter((run) => Boolean(run))
+        .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+}
+export async function resolveRun(repoRoot, runId) {
+    if (runId) {
+        return await loadRunRecord(repoRoot, runId);
+    }
+    const runs = await listRuns(repoRoot);
+    return runs[0] ?? null;
+}
+export async function loadUndoStack(repoRoot) {
+    const stack = await readJson(undoStackPath(repoRoot));
+    return Array.isArray(stack) ? stack : [];
+}
+export async function pushUndoEntry(repoRoot, entry) {
+    await updateJson(undoStackPath(repoRoot), (current) => {
+        const stack = Array.isArray(current) ? current : [];
+        return [...stack, entry];
+    });
+}
+export async function popUndoEntry(repoRoot) {
+    let popped = null;
+    await updateJson(undoStackPath(repoRoot), (current) => {
+        const stack = Array.isArray(current) ? [...current] : [];
+        popped = stack.pop() ?? null;
+        return stack;
+    });
+    return popped;
+}
+// ---------------------------------------------------------------------------
+// Multi-project registry (~/.rudder/projects.json). The localhost board serves
+// every registered repo; runs auto-register their repo so projects appear.
+// ---------------------------------------------------------------------------
+export async function loadProjects() {
+    const registry = await readJson(projectsRegistryPath());
+    if (registry?.version === 1 && Array.isArray(registry.projects)) {
+        return registry.projects.filter((entry) => Boolean(entry) && typeof entry.slug === "string" && typeof entry.repoRoot === "string");
+    }
+    return [];
+}
+/**
+ * Compute a stable slug for a repo: slugify(basename) with a -<shortHash> suffix
+ * appended only when another already-registered repo claimed the bare slug.
+ */
+function computeProjectSlug(repoRoot, existing) {
+    const resolved = path.resolve(repoRoot);
+    const base = slugify(path.basename(resolved), "project");
+    const collision = existing.some((entry) => entry.slug === base && path.resolve(entry.repoRoot) !== resolved);
+    return collision ? `${base}-${shortHash(resolved)}` : base;
+}
+/**
+ * Register the given repo in the global registry. Idempotent: an existing entry
+ * for the same repoRoot is returned unchanged (its slug is stable). Never throws
+ * on a malformed registry (it is rebuilt from the known-good entries).
+ */
+export async function registerProject(repoRoot) {
+    const resolved = path.resolve(repoRoot);
+    let result = null;
+    await updateJson(projectsRegistryPath(), (current) => {
+        const projects = current?.version === 1 && Array.isArray(current.projects)
+            ? current.projects.filter((entry) => Boolean(entry) && typeof entry.slug === "string" && typeof entry.repoRoot === "string")
+            : [];
+        const found = projects.find((entry) => path.resolve(entry.repoRoot) === resolved);
+        if (found) {
+            result = found;
+            return { version: 1, projects };
+        }
+        const entry = {
+            slug: computeProjectSlug(resolved, projects),
+            repoRoot: resolved,
+            name: path.basename(resolved),
+            addedAt: nowIso(),
+        };
+        result = entry;
+        return { version: 1, projects: [...projects, entry] };
+    });
+    if (!result) {
+        // Should be unreachable; the transform always assigns result.
+        result = {
+            slug: computeProjectSlug(resolved, []),
+            repoRoot: resolved,
+            name: path.basename(resolved),
+            addedAt: nowIso(),
+        };
+    }
+    return result;
+}
+export async function findProjectBySlug(slug) {
+    const projects = await loadProjects();
+    return projects.find((entry) => entry.slug === slug) ?? null;
+}
+//# sourceMappingURL=state.js.map