aimux-cli 0.1.16 → 0.1.19

package/dist/runtime-core/topology-store.js

@@ -0,0 +1,419 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse, stringify } from "yaml";
+import { getRuntimeTopologyPath } from "../paths.js";
+export const RUNTIME_TOPOLOGY_VERSION = 1;
+const UPDATE_LOCK_TIMEOUT_MS = 5_000;
+const UPDATE_LOCK_RETRY_MS = 25;
+export function emptyRuntimeTopology(now = new Date().toISOString()) {
+    return {
+        version: RUNTIME_TOPOLOGY_VERSION,
+        generatedAt: now,
+        rigs: [],
+        nodes: [],
+        edges: [],
+        bindings: [],
+        sessions: [],
+        services: [],
+        worktrees: [],
+        worktreeGraveyard: [],
+        teamRoles: [],
+        remoteClients: [],
+        lifecycleOperations: [],
+        exchangeRefs: [],
+    };
+}
+function asRecord(value, context) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`invalid runtime topology: ${context} must be an object`);
+    }
+    return value;
+}
+function asString(value, context) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`invalid runtime topology: ${context} must be a non-empty string`);
+    }
+    return value;
+}
+function asOptionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.map((entry) => String(entry));
+}
+function asOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function normalizeRuntimeTopology(topology) {
+    const rigIds = new Set(topology.rigs.map((rig) => rig.id));
+    const nodes = topology.nodes.filter((node) => rigIds.has(node.rigId));
+    const nodeIds = new Set(nodes.map((node) => node.id));
+    const sessions = topology.sessions.filter((session) => nodeIds.has(session.nodeId));
+    const sessionIds = new Set(sessions.map((session) => session.id));
+    const services = topology.services.filter((service) => rigIds.has(service.rigId) && (!service.nodeId || nodeIds.has(service.nodeId)));
+    const serviceIds = new Set(services.map((service) => service.id));
+    const worktrees = topology.worktrees.filter((worktree) => rigIds.has(worktree.rigId));
+    const worktreeIds = new Set(worktrees.map((worktree) => worktree.id));
+    const hasLifecycleTarget = (operation) => {
+        if (operation.targetKind === "rig")
+            return rigIds.has(operation.targetId);
+        if (operation.targetKind === "node")
+            return nodeIds.has(operation.targetId);
+        if (operation.targetKind === "session")
+            return sessionIds.has(operation.targetId);
+        if (operation.targetKind === "service")
+            return serviceIds.has(operation.targetId);
+        return worktreeIds.has(operation.targetId);
+    };
+    return {
+        ...topology,
+        nodes,
+        edges: topology.edges.filter((edge) => rigIds.has(edge.rigId) && nodeIds.has(edge.sourceNodeId) && nodeIds.has(edge.targetNodeId)),
+        bindings: topology.bindings.filter((binding) => nodeIds.has(binding.nodeId)),
+        sessions,
+        services,
+        worktrees,
+        worktreeGraveyard: topology.worktreeGraveyard.filter((entry) => rigIds.has(entry.rigId)),
+        teamRoles: topology.teamRoles.filter((role) => rigIds.has(role.rigId) &&
+            (!role.nodeId || nodeIds.has(role.nodeId)) &&
+            (!role.parentNodeId || nodeIds.has(role.parentNodeId))),
+        remoteClients: topology.remoteClients
+            .filter((client) => rigIds.has(client.rigId))
+            .map((client) => ({
+            ...client,
+            ownsSessionIds: client.ownsSessionIds?.filter((sessionId) => sessionIds.has(sessionId)),
+        })),
+        lifecycleOperations: topology.lifecycleOperations.filter((operation) => rigIds.has(operation.rigId) && hasLifecycleTarget(operation)),
+        exchangeRefs: topology.exchangeRefs.filter((ref) => rigIds.has(ref.rigId) &&
+            (!ref.nodeId || nodeIds.has(ref.nodeId)) &&
+            (!ref.sessionId || sessionIds.has(ref.sessionId))),
+    };
+}
+function coerceRuntimeTopology(raw) {
+    const record = asRecord(raw, "root");
+    if (record.version !== RUNTIME_TOPOLOGY_VERSION) {
+        throw new Error(`unsupported runtime topology version: ${String(record.version)}`);
+    }
+    return normalizeRuntimeTopology({
+        version: RUNTIME_TOPOLOGY_VERSION,
+        generatedAt: asString(record.generatedAt, "generatedAt"),
+        rigs: asArray(record.rigs).map((entry, index) => {
+            const row = asRecord(entry, `rigs[${index}]`);
+            return {
+                id: asString(row.id, `rigs[${index}].id`),
+                name: asString(row.name, `rigs[${index}].name`),
+                projectRoot: asString(row.projectRoot, `rigs[${index}].projectRoot`),
+                createdAt: asString(row.createdAt, `rigs[${index}].createdAt`),
+                updatedAt: asString(row.updatedAt, `rigs[${index}].updatedAt`),
+            };
+        }),
+        nodes: asArray(record.nodes).map((entry, index) => {
+            const row = asRecord(entry, `nodes[${index}]`);
+            return {
+                id: asString(row.id, `nodes[${index}].id`),
+                rigId: asString(row.rigId, `nodes[${index}].rigId`),
+                logicalId: asString(row.logicalId, `nodes[${index}].logicalId`),
+                role: asOptionalString(row.role),
+                runtime: asOptionalString(row.runtime),
+                toolConfigKey: asOptionalString(row.toolConfigKey),
+                model: asOptionalString(row.model),
+                cwd: asOptionalString(row.cwd),
+                label: asOptionalString(row.label),
+                createdAt: asString(row.createdAt, `nodes[${index}].createdAt`),
+            };
+        }),
+        edges: asArray(record.edges).map((entry, index) => {
+            const row = asRecord(entry, `edges[${index}]`);
+            return {
+                id: asString(row.id, `edges[${index}].id`),
+                rigId: asString(row.rigId, `edges[${index}].rigId`),
+                sourceNodeId: asString(row.sourceNodeId, `edges[${index}].sourceNodeId`),
+                targetNodeId: asString(row.targetNodeId, `edges[${index}].targetNodeId`),
+                kind: asString(row.kind, `edges[${index}].kind`),
+                createdAt: asString(row.createdAt, `edges[${index}].createdAt`),
+            };
+        }),
+        bindings: asArray(record.bindings).map((entry, index) => {
+            const row = asRecord(entry, `bindings[${index}]`);
+            return {
+                id: asString(row.id, `bindings[${index}].id`),
+                nodeId: asString(row.nodeId, `bindings[${index}].nodeId`),
+                tmuxSession: asOptionalString(row.tmuxSession),
+                tmuxWindowId: asOptionalString(row.tmuxWindowId),
+                tmuxWindowIndex: asOptionalNumber(row.tmuxWindowIndex),
+                tmuxWindowName: asOptionalString(row.tmuxWindowName),
+                tmuxPane: asOptionalString(row.tmuxPane),
+                updatedAt: asString(row.updatedAt, `bindings[${index}].updatedAt`),
+            };
+        }),
+        sessions: asArray(record.sessions).map((entry, index) => {
+            const row = asRecord(entry, `sessions[${index}]`);
+            return {
+                id: asString(row.id, `sessions[${index}].id`),
+                nodeId: asString(row.nodeId, `sessions[${index}].nodeId`),
+                status: asRuntimeSessionStatus(row.status),
+                tool: asOptionalString(row.tool),
+                command: asOptionalString(row.command),
+                args: asStringArray(row.args),
+                backendSessionId: asOptionalString(row.backendSessionId),
+                worktreePath: asOptionalString(row.worktreePath),
+                label: asOptionalString(row.label),
+                headline: asOptionalString(row.headline),
+                team: row.team,
+                createdAt: asString(row.createdAt, `sessions[${index}].createdAt`),
+                updatedAt: asString(row.updatedAt, `sessions[${index}].updatedAt`),
+                lastSeenAt: asOptionalString(row.lastSeenAt),
+            };
+        }),
+        services: asArray(record.services).map((entry, index) => {
+            const row = asRecord(entry, `services[${index}]`);
+            return {
+                id: asString(row.id, `services[${index}].id`),
+                rigId: asString(row.rigId, `services[${index}].rigId`),
+                nodeId: asOptionalString(row.nodeId),
+                status: asServiceStatus(row.status),
+                command: asOptionalString(row.command),
+                args: asStringArray(row.args),
+                launchCommandLine: asOptionalString(row.launchCommandLine),
+                worktreePath: asOptionalString(row.worktreePath),
+                cwd: asOptionalString(row.cwd),
+                label: asOptionalString(row.label),
+                createdAt: asString(row.createdAt, `services[${index}].createdAt`),
+                updatedAt: asString(row.updatedAt, `services[${index}].updatedAt`),
+                lastSeenAt: asOptionalString(row.lastSeenAt),
+            };
+        }),
+        worktrees: asArray(record.worktrees).map((entry, index) => {
+            const row = asRecord(entry, `worktrees[${index}]`);
+            return {
+                id: asString(row.id, `worktrees[${index}].id`),
+                rigId: asString(row.rigId, `worktrees[${index}].rigId`),
+                path: asString(row.path, `worktrees[${index}].path`),
+                name: asString(row.name, `worktrees[${index}].name`),
+                status: asWorktreeStatus(row.status),
+                branch: asOptionalString(row.branch),
+                head: asOptionalString(row.head),
+                basePath: asOptionalString(row.basePath),
+                createdAt: asString(row.createdAt, `worktrees[${index}].createdAt`),
+                updatedAt: asString(row.updatedAt, `worktrees[${index}].updatedAt`),
+                removedAt: asOptionalString(row.removedAt),
+                operationFailure: asOptionalString(row.operationFailure),
+            };
+        }),
+        worktreeGraveyard: asArray(record.worktreeGraveyard).map((entry, index) => {
+            const row = asRecord(entry, `worktreeGraveyard[${index}]`);
+            return {
+                id: asString(row.id, `worktreeGraveyard[${index}].id`),
+                rigId: asString(row.rigId, `worktreeGraveyard[${index}].rigId`),
+                worktreeId: asOptionalString(row.worktreeId),
+                path: asString(row.path, `worktreeGraveyard[${index}].path`),
+                name: asOptionalString(row.name),
+                branch: asOptionalString(row.branch),
+                graveyardedAt: asString(row.graveyardedAt, `worktreeGraveyard[${index}].graveyardedAt`),
+                reason: asOptionalString(row.reason),
+                deletedAt: asOptionalString(row.deletedAt),
+            };
+        }),
+        teamRoles: asArray(record.teamRoles).map((entry, index) => {
+            const row = asRecord(entry, `teamRoles[${index}]`);
+            return {
+                id: asString(row.id, `teamRoles[${index}].id`),
+                rigId: asString(row.rigId, `teamRoles[${index}].rigId`),
+                nodeId: asOptionalString(row.nodeId),
+                parentNodeId: asOptionalString(row.parentNodeId),
+                role: asString(row.role, `teamRoles[${index}].role`),
+                label: asOptionalString(row.label),
+                order: asOptionalNumber(row.order),
+                createdAt: asString(row.createdAt, `teamRoles[${index}].createdAt`),
+                updatedAt: asString(row.updatedAt, `teamRoles[${index}].updatedAt`),
+            };
+        }),
+        remoteClients: asArray(record.remoteClients).map((entry, index) => {
+            const row = asRecord(entry, `remoteClients[${index}]`);
+            return {
+                id: asString(row.id, `remoteClients[${index}].id`),
+                rigId: asString(row.rigId, `remoteClients[${index}].rigId`),
+                userId: asOptionalString(row.userId),
+                displayName: asOptionalString(row.displayName),
+                shareId: asOptionalString(row.shareId),
+                ownerUserId: asOptionalString(row.ownerUserId),
+                status: asRemoteClientStatus(row.status),
+                connectedAt: asOptionalString(row.connectedAt),
+                lastSeenAt: asString(row.lastSeenAt, `remoteClients[${index}].lastSeenAt`),
+                ownsSessionIds: asStringArray(row.ownsSessionIds),
+            };
+        }),
+        lifecycleOperations: asArray(record.lifecycleOperations).map((entry, index) => {
+            const row = asRecord(entry, `lifecycleOperations[${index}]`);
+            return {
+                id: asString(row.id, `lifecycleOperations[${index}].id`),
+                rigId: asString(row.rigId, `lifecycleOperations[${index}].rigId`),
+                kind: asString(row.kind, `lifecycleOperations[${index}].kind`),
+                status: asLifecycleOperationStatus(row.status),
+                targetKind: asLifecycleOperationTargetKind(row.targetKind, `lifecycleOperations[${index}].targetKind`),
+                targetId: asString(row.targetId, `lifecycleOperations[${index}].targetId`),
+                requestedBy: asOptionalString(row.requestedBy),
+                startedAt: asString(row.startedAt, `lifecycleOperations[${index}].startedAt`),
+                updatedAt: asString(row.updatedAt, `lifecycleOperations[${index}].updatedAt`),
+                completedAt: asOptionalString(row.completedAt),
+                error: asOptionalString(row.error),
+            };
+        }),
+        exchangeRefs: asArray(record.exchangeRefs).map((entry, index) => {
+            const row = asRecord(entry, `exchangeRefs[${index}]`);
+            return {
+                id: asString(row.id, `exchangeRefs[${index}].id`),
+                rigId: asString(row.rigId, `exchangeRefs[${index}].rigId`),
+                kind: asExchangeRefKind(row.kind, `exchangeRefs[${index}].kind`),
+                exchangeId: asString(row.exchangeId, `exchangeRefs[${index}].exchangeId`),
+                nodeId: asOptionalString(row.nodeId),
+                sessionId: asOptionalString(row.sessionId),
+                createdAt: asString(row.createdAt, `exchangeRefs[${index}].createdAt`),
+                updatedAt: asString(row.updatedAt, `exchangeRefs[${index}].updatedAt`),
+            };
+        }),
+    });
+}
+function asRuntimeSessionStatus(value) {
+    const status = String(value);
+    if (status === "planned" ||
+        status === "starting" ||
+        status === "running" ||
+        status === "idle" ||
+        status === "offline" ||
+        status === "graveyard" ||
+        status === "error") {
+        return status;
+    }
+    return "error";
+}
+function asServiceStatus(value) {
+    const status = String(value);
+    if (status === "planned" ||
+        status === "starting" ||
+        status === "running" ||
+        status === "stopped" ||
+        status === "offline" ||
+        status === "error") {
+        return status;
+    }
+    return "error";
+}
+function asWorktreeStatus(value) {
+    const status = String(value);
+    if (status === "planned" ||
+        status === "creating" ||
+        status === "active" ||
+        status === "removing" ||
+        status === "graveyard" ||
+        status === "missing" ||
+        status === "error") {
+        return status;
+    }
+    return "error";
+}
+function asRemoteClientStatus(value) {
+    const status = String(value);
+    if (status === "online" || status === "stale" || status === "offline")
+        return status;
+    return "offline";
+}
+function asLifecycleOperationStatus(value) {
+    const status = String(value);
+    if (status === "pending" ||
+        status === "running" ||
+        status === "succeeded" ||
+        status === "failed" ||
+        status === "cancelled") {
+        return status;
+    }
+    return "failed";
+}
+function asLifecycleOperationTargetKind(value, context) {
+    const kind = String(value);
+    if (kind === "session" || kind === "service" || kind === "worktree" || kind === "node" || kind === "rig") {
+        return kind;
+    }
+    throw new Error(`invalid runtime topology: ${context} must be a supported target kind`);
+}
+function asExchangeRefKind(value, context) {
+    const kind = String(value);
+    if (kind === "message" ||
+        kind === "handoff" ||
+        kind === "task" ||
+        kind === "review" ||
+        kind === "plan" ||
+        kind === "wait" ||
+        kind === "continuity" ||
+        kind === "attachment") {
+        return kind;
+    }
+    throw new Error(`invalid runtime topology: ${context} must be a supported exchange ref kind`);
+}
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+export class RuntimeTopologyStore {
+    path;
+    constructor(path = getRuntimeTopologyPath()) {
+        this.path = path;
+    }
+    read() {
+        if (!existsSync(this.path))
+            return emptyRuntimeTopology();
+        const parsed = parse(readFileSync(this.path, "utf-8"));
+        return coerceRuntimeTopology(parsed);
+    }
+    write(topology) {
+        mkdirSync(dirname(this.path), { recursive: true });
+        const normalized = coerceRuntimeTopology(topology);
+        const tmpPath = `${this.path}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+        writeFileSync(tmpPath, stringify(normalized, {
+            lineWidth: 120,
+            sortMapEntries: false,
+        }));
+        renameSync(tmpPath, this.path);
+        return normalized;
+    }
+    acquireUpdateLock() {
+        mkdirSync(dirname(this.path), { recursive: true });
+        const lockPath = `${this.path}.lock`;
+        const deadline = Date.now() + UPDATE_LOCK_TIMEOUT_MS;
+        while (true) {
+            try {
+                mkdirSync(lockPath);
+                try {
+                    writeFileSync(join(lockPath, "owner"), `${process.pid}\n`);
+                }
+                catch (ownerError) {
+                    rmSync(lockPath, { recursive: true, force: true });
+                    throw ownerError;
+                }
+                return () => rmSync(lockPath, { recursive: true, force: true });
+            }
+            catch (error) {
+                if (Date.now() >= deadline) {
+                    throw new Error(`Timed out acquiring runtime topology update lock at ${lockPath}`, { cause: error });
+                }
+                sleepSync(UPDATE_LOCK_RETRY_MS);
+            }
+        }
+    }
+    update(mutator) {
+        const release = this.acquireUpdateLock();
+        try {
+            return this.write(mutator(this.read()));
+        }
+        finally {
+            release();
+        }
+    }
+}
+export function createRuntimeTopologyStore(path) {
+    return new RuntimeTopologyStore(path);
+}

package/dist/runtime-core/topology-worktrees.d.ts

@@ -0,0 +1,60 @@
+import { type RuntimeTopology, type RuntimeTopologyStore, type RuntimeTopologyWorktree, type RuntimeTopologyWorktreeGraveyardEntry, type RuntimeTopologyWorktreeStatus } from "./topology-store.js";
+export type RuntimeTopologyWorktreeState = {
+    id?: string;
+    path: string;
+    name?: string;
+    status?: RuntimeTopologyWorktreeStatus;
+    branch?: string;
+    head?: string;
+    basePath?: string;
+    createdAt?: string;
+    removedAt?: string;
+    operationFailure?: string;
+};
+export type RuntimeTopologyWorktreeGraveyardState = {
+    id: string;
+    worktreeId?: string;
+    path: string;
+    name?: string;
+    branch?: string;
+    graveyardedAt: string;
+    reason?: string;
+    deletedAt?: string;
+};
+export declare function topologyWorktreeToWorktreeState(worktree: RuntimeTopologyWorktree): RuntimeTopologyWorktreeState;
+export declare function topologyWorktreeGraveyardToState(entry: RuntimeTopologyWorktreeGraveyardEntry): RuntimeTopologyWorktreeGraveyardState;
+export declare function listTopologyWorktreeStates(input?: {
+    statuses?: RuntimeTopologyWorktreeStatus[];
+    store?: RuntimeTopologyStore;
+}): RuntimeTopologyWorktreeState[];
+export declare function listTopologyWorktreeGraveyard(input?: {
+    includeDeleted?: boolean;
+    store?: RuntimeTopologyStore;
+}): RuntimeTopologyWorktreeGraveyardState[];
+export declare function listTopologyWorktreeGraveyardPaths(input?: {
+    store?: RuntimeTopologyStore;
+}): Set<string>;
+export declare function upsertTopologyWorktree(worktree: RuntimeTopologyWorktreeState, status: RuntimeTopologyWorktreeStatus, input?: {
+    store?: RuntimeTopologyStore;
+    now?: string;
+    projectRoot?: string;
+}): RuntimeTopology;
+export declare function moveTopologyWorktreeToGraveyard(path: string, input?: {
+    store?: RuntimeTopologyStore;
+    now?: string;
+    reason?: string;
+    projectRoot?: string;
+}): RuntimeTopologyWorktreeGraveyardState | undefined;
+export declare function deleteTopologyWorktreeGraveyardEntry(path: string, input?: {
+    store?: RuntimeTopologyStore;
+    now?: string;
+}): RuntimeTopologyWorktreeGraveyardState | undefined;
+export declare function resurrectTopologyWorktreeFromGraveyard(path: string, input?: {
+    store?: RuntimeTopologyStore;
+    now?: string;
+    projectRoot?: string;
+}): RuntimeTopologyWorktreeState | undefined;
+export declare function removeTopologyWorktree(path: string, input?: {
+    store?: RuntimeTopologyStore;
+    now?: string;
+}): RuntimeTopologyWorktreeState | undefined;

package/dist/runtime-core/topology-worktrees.js

@@ -0,0 +1,199 @@
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+import { getProjectId, getRepoRoot } from "../paths.js";
+import { createRuntimeTopologyStore, emptyRuntimeTopology, } from "./topology-store.js";
+function worktreeIdForPath(path) {
+    return `worktree:${createHash("sha256").update(path).digest("base64url").slice(0, 24)}`;
+}
+function graveyardIdForPath(path) {
+    return `worktree-graveyard:${createHash("sha256").update(path).digest("base64url").slice(0, 24)}`;
+}
+function ensureRig(topology, projectRoot, now) {
+    const id = getProjectId();
+    const existing = topology.rigs.find((rig) => rig.id === id);
+    if (existing) {
+        existing.projectRoot = projectRoot;
+        existing.name = basename(projectRoot);
+        existing.updatedAt = now;
+        return existing.id;
+    }
+    topology.rigs.push({
+        id,
+        name: basename(projectRoot),
+        projectRoot,
+        createdAt: now,
+        updatedAt: now,
+    });
+    return id;
+}
+function worktreeToTopologyWorktree(worktree, rigId, status, now) {
+    return {
+        id: worktree.id ?? worktreeIdForPath(worktree.path),
+        rigId,
+        path: worktree.path,
+        name: worktree.name ?? basename(worktree.path),
+        status,
+        branch: worktree.branch,
+        head: worktree.head,
+        basePath: worktree.basePath,
+        createdAt: worktree.createdAt ?? now,
+        updatedAt: now,
+        removedAt: worktree.removedAt,
+        operationFailure: worktree.operationFailure,
+    };
+}
+export function topologyWorktreeToWorktreeState(worktree) {
+    return {
+        id: worktree.id,
+        path: worktree.path,
+        name: worktree.name,
+        status: worktree.status,
+        branch: worktree.branch,
+        head: worktree.head,
+        basePath: worktree.basePath,
+        createdAt: worktree.createdAt,
+        removedAt: worktree.removedAt,
+        operationFailure: worktree.operationFailure,
+    };
+}
+export function topologyWorktreeGraveyardToState(entry) {
+    return {
+        id: entry.id,
+        worktreeId: entry.worktreeId,
+        path: entry.path,
+        name: entry.name,
+        branch: entry.branch,
+        graveyardedAt: entry.graveyardedAt,
+        reason: entry.reason,
+        deletedAt: entry.deletedAt,
+    };
+}
+export function listTopologyWorktreeStates(input) {
+    const topology = (input?.store ?? createRuntimeTopologyStore()).read();
+    const statuses = input?.statuses ? new Set(input.statuses) : undefined;
+    return topology.worktrees
+        .filter((worktree) => !statuses || statuses.has(worktree.status))
+        .map(topologyWorktreeToWorktreeState);
+}
+export function listTopologyWorktreeGraveyard(input) {
+    const topology = (input?.store ?? createRuntimeTopologyStore()).read();
+    return topology.worktreeGraveyard
+        .filter((entry) => input?.includeDeleted || !entry.deletedAt)
+        .map(topologyWorktreeGraveyardToState);
+}
+export function listTopologyWorktreeGraveyardPaths(input) {
+    return new Set(listTopologyWorktreeGraveyard(input).map((entry) => entry.path));
+}
+export function upsertTopologyWorktree(worktree, status, input) {
+    const store = input?.store ?? createRuntimeTopologyStore();
+    const now = input?.now ?? new Date().toISOString();
+    const projectRoot = input?.projectRoot ?? getRepoRoot();
+    return store.update((current) => {
+        const topology = current.version ? current : emptyRuntimeTopology(now);
+        topology.generatedAt = now;
+        const rigId = ensureRig(topology, projectRoot, now);
+        const next = worktreeToTopologyWorktree(worktree, rigId, status, now);
+        topology.worktrees = [...topology.worktrees.filter((entry) => entry.id !== next.id), next];
+        return topology;
+    });
+}
+export function moveTopologyWorktreeToGraveyard(path, input) {
+    const store = input?.store ?? createRuntimeTopologyStore();
+    const now = input?.now ?? new Date().toISOString();
+    const projectRoot = input?.projectRoot ?? getRepoRoot();
+    let moved;
+    store.update((current) => {
+        const topology = current.version ? current : emptyRuntimeTopology(now);
+        topology.generatedAt = now;
+        const rigId = ensureRig(topology, projectRoot, now);
+        const existing = topology.worktrees.find((worktree) => worktree.path === path);
+        if (!existing)
+            return topology;
+        const graveyardEntry = {
+            id: graveyardIdForPath(path),
+            rigId,
+            worktreeId: existing.id,
+            path,
+            name: existing.name,
+            branch: existing.branch,
+            graveyardedAt: now,
+            reason: input?.reason,
+        };
+        existing.status = "graveyard";
+        existing.removedAt = now;
+        existing.updatedAt = now;
+        topology.worktreeGraveyard = [...topology.worktreeGraveyard.filter((entry) => entry.path !== path), graveyardEntry];
+        moved = topologyWorktreeGraveyardToState(graveyardEntry);
+        return topology;
+    });
+    return moved;
+}
+export function deleteTopologyWorktreeGraveyardEntry(path, input) {
+    const store = input?.store ?? createRuntimeTopologyStore();
+    const now = input?.now ?? new Date().toISOString();
+    let deleted;
+    store.update((topology) => {
+        const existing = topology.worktreeGraveyard.find((entry) => entry.path === path && !entry.deletedAt);
+        if (!existing)
+            return topology;
+        existing.deletedAt = now;
+        topology.generatedAt = now;
+        deleted = topologyWorktreeGraveyardToState(existing);
+        return topology;
+    });
+    return deleted;
+}
+export function resurrectTopologyWorktreeFromGraveyard(path, input) {
+    const store = input?.store ?? createRuntimeTopologyStore();
+    const now = input?.now ?? new Date().toISOString();
+    const projectRoot = input?.projectRoot ?? getRepoRoot();
+    let resurrected;
+    store.update((current) => {
+        const topology = current.version ? current : emptyRuntimeTopology(now);
+        topology.generatedAt = now;
+        const rigId = ensureRig(topology, projectRoot, now);
+        const graveyardEntry = topology.worktreeGraveyard.find((entry) => entry.path === path && !entry.deletedAt);
+        if (!graveyardEntry)
+            return topology;
+        const existing = topology.worktrees.find((worktree) => worktree.id === graveyardEntry.worktreeId || worktree.path === path);
+        if (existing) {
+            existing.rigId = rigId;
+            existing.path = path;
+            existing.name = existing.name ?? graveyardEntry.name;
+            existing.branch = existing.branch ?? graveyardEntry.branch;
+            existing.status = "active";
+            existing.updatedAt = now;
+            delete existing.removedAt;
+            resurrected = topologyWorktreeToWorktreeState(existing);
+        }
+        else {
+            const next = worktreeToTopologyWorktree({
+                path,
+                name: graveyardEntry.name,
+                branch: graveyardEntry.branch,
+                createdAt: graveyardEntry.graveyardedAt,
+            }, rigId, "active", now);
+            topology.worktrees.push(next);
+            resurrected = topologyWorktreeToWorktreeState(next);
+        }
+        topology.worktreeGraveyard = topology.worktreeGraveyard.filter((entry) => entry.path !== path);
+        return topology;
+    });
+    return resurrected;
+}
+export function removeTopologyWorktree(path, input) {
+    const store = input?.store ?? createRuntimeTopologyStore();
+    const now = input?.now ?? new Date().toISOString();
+    let removed;
+    store.update((topology) => {
+        const existing = topology.worktrees.find((worktree) => worktree.path === path);
+        if (!existing)
+            return topology;
+        removed = topologyWorktreeToWorktreeState(existing);
+        topology.generatedAt = now;
+        topology.worktrees = topology.worktrees.filter((worktree) => worktree.path !== path);
+        topology.lifecycleOperations = topology.lifecycleOperations.filter((operation) => !(operation.targetKind === "worktree" && operation.targetId === existing.id));
+        return topology;
+    });
+    return removed;
+}