@hunsu/core 0.1.0

package/dist/domain-store.js

@@ -0,0 +1,951 @@
+import { createHash } from "node:crypto";
+import { gzipSync, gunzipSync } from "node:zlib";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createDefaultHarness, decodeArtifactActionDefinitionArray, harnessEntityFromSnapshot, err, ok, rootHarnessSnapshot, tryProjectBoard, tryApplyCommand, validateHarnessEntity, validateDomainEvent } from "@hunsu/protocol";
+import { GitError } from "./errors.js";
+import { ensureGitRepository, git } from "./git.js";
+import { parseCommitSha, parseRuntimeChecksum } from "./primitives.js";
+export const HUNSU_COMPLETED_DESTINATIONS_PATH = ".hunsu/completed-destinations.hunsu";
+export const HUNSU_DESTINATIONS_PATH = ".hunsu/destinations.hunsu";
+export const HUNSU_HARNESS_PATH = ".hunsu/harness.hunsu";
+export const HUNSU_EXECUTORS_PATH = ".hunsu/executors.hunsu";
+export const HUNSU_RESOURCES_PATH = ".hunsu/resources.hunsu";
+export const HUNSU_ARTIFACT_ACTIONS_PATH = ".hunsu/artifact-actions.hunsu";
+export const HUNSU_CURRENT_EXECUTION_PATH = ".hunsu/current-execution.hunsu";
+export const HUNSU_PREVIOUS_EXECUTION_PATH = ".hunsu/previous-execution.hunsu";
+export const HUNSU_HUNSU_DRAFT_PATH = ".hunsu/hunsu-draft.hunsu";
+export const HUNSU_RUNTIME_PATHS = [HUNSU_COMPLETED_DESTINATIONS_PATH, HUNSU_DESTINATIONS_PATH, HUNSU_HARNESS_PATH, HUNSU_EXECUTORS_PATH, HUNSU_RESOURCES_PATH, HUNSU_ARTIFACT_ACTIONS_PATH];
+export const HUNSU_LEGACY_STATE_PATH = ".hunsu/state.hunsu";
+export const HUNSU_RUNTIME_ENCODING = "gzip+base64url";
+export const HUNSU_DRAFT_RUNTIME_FILE_NAMES = ["destinations.json", "harness.json", "executors.json", "resources.json", "artifact-actions.json"];
+export const HUNSU_SELF_COMMIT_REF = { type: "self" };
+export const HUNSU_SELF_COMMIT_SENTINEL = "__HUNSU_SELF_COMMIT__";
+const HUNSU_RUNTIME_HEADER = "HUNSU_RUNTIME_FILE_V1";
+const LEGACY_STATE_HEADER = "HUNSU_STATE_V1";
+const DOMAIN_EVENT_REF_PREFIX = "refs/hunsu/events";
+const DOMAIN_EVENT_REF_FORMAT = "%(refname)\t%(objectname)\t%(objecttype)";
+const DOMAIN_EVENT_REF_SEPARATOR = "\t";
+export function loadDomainStore(cwd = process.cwd()) {
+    const root = ensureGitRepository(cwd);
+    const worktreeRuntime = readHunsuRuntimeStateFromWorktree(root);
+    const reachableRuntime = readLatestReachableHunsuRuntimeState(root);
+    if (worktreeRuntime && (!reachableRuntime || runtimeEventCount(worktreeRuntime.runtime) >= runtimeEventCount(reachableRuntime.runtime))) {
+        return domainStoreFromRuntime(root, worktreeRuntime.runtime, "worktree-runtime", [], worktreeRuntime.checksum);
+    }
+    if (reachableRuntime) {
+        return domainStoreFromRuntime(root, reachableRuntime.runtime, "reachable-runtime", [], reachableRuntime.checksum, reachableRuntime.commit);
+    }
+    const legacyState = readLegacyHunsuRuntimeStateFromWorktree(root) ?? readLegacyHunsuRuntimeStateAtRef(root, "HEAD");
+    if (legacyState) {
+        const runtime = runtimeFromEvents(legacyState.state.events, undefined, legacyState.state.events);
+        return domainStoreFromRuntime(root, runtime, "legacy-state", [], checksumRuntimeState(runtime));
+    }
+    const eventRefs = readDomainEventRefs(root);
+    if (eventRefs.length > 0) {
+        const events = eventRefs.map(ref => unwrapDomainStoreResult(readDomainEventObject(root, ref)));
+        const runtime = runtimeFromEvents(events, undefined, events);
+        return domainStoreFromRuntime(root, runtime, "legacy-refs", eventRefs, checksumRuntimeState(runtime));
+    }
+    const runtime = runtimeFromEvents([]);
+    return domainStoreFromRuntime(root, runtime, "empty", [], checksumRuntimeState(runtime));
+}
+export function initializeDomainStore(cwd = process.cwd(), options = {}) {
+    const root = ensureGitRepository(cwd);
+    const store = loadDomainStore(root);
+    if (store.source === "worktree-runtime") {
+        return store;
+    }
+    writeHunsuRuntimeState(root, store.runtime);
+    commitRuntimeStateIfRequested(root, options.commitMessage);
+    return {
+        ...store,
+        source: "worktree-runtime"
+    };
+}
+export function dryRunCommand(command, cwd = process.cwd()) {
+    return dryRunCommands([command], cwd);
+}
+export function dryRunCommands(commands, cwd = process.cwd()) {
+    const store = loadDomainStore(cwd);
+    const nextEvents = commands.reduce((events, command) => {
+        const result = tryApplyCommand(events, command);
+        if (!result.ok) {
+            throw new Error(result.error.message);
+        }
+        return result.value;
+    }, store.events);
+    const acceptedEvents = nextEvents.slice(store.events.length);
+    return { store, acceptedEvents, board: projectDomainEvents(nextEvents, "dry-run commands") };
+}
+export function writeCommand(command, options = {}) {
+    return writeCommands([command], options);
+}
+export function writeCommands(commands, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const { store, acceptedEvents, board } = dryRunCommands(commands, cwd);
+    if (acceptedEvents.length > 0) {
+        const nextRuntime = runtimeFromEvents([...store.events, ...acceptedEvents], store.runtime, acceptedEvents, options.previousExecution);
+        writeHunsuRuntimeState(store.root, nextRuntime, { selfCommitMoveIds: options.selfCommitMoveIds });
+        commitRuntimeStateIfRequested(store.root, options.commitMessage);
+    }
+    return { acceptedEvents, board };
+}
+export function encodeHunsuRuntimeFile(value) {
+    const json = `${JSON.stringify(value)}\n`;
+    const checksum = parseRuntimeChecksum(sha256(json));
+    const payload = gzipSync(Buffer.from(json, "utf8")).toString("base64url");
+    return {
+        checksum,
+        text: `${HUNSU_RUNTIME_HEADER}\nencoding: ${HUNSU_RUNTIME_ENCODING}\nchecksum: sha256:${checksum}\n\n${payload}\n`
+    };
+}
+export function decodeHunsuRuntimeFileText(text, source) {
+    const decoded = decodeRuntimeEnvelope(text, source, HUNSU_RUNTIME_HEADER);
+    if (!decoded.ok) {
+        return decoded;
+    }
+    return ok(decoded.value.value);
+}
+export function decodeRuntimeBundleToDraftFiles(runtime) {
+    const bundle = hunsuDraftRuntimeBundleFromRuntime(runtime);
+    return {
+        "destinations.json": bundle.destinations,
+        "harness.json": bundle.harness,
+        "executors.json": bundle.executors,
+        "resources.json": bundle.resources,
+        "artifact-actions.json": bundle.artifactActions
+    };
+}
+export function hunsuDraftRuntimeBundleFromRuntime(runtime) {
+    return {
+        destinations: cloneJson(runtime.destinations),
+        harness: cloneJson(runtime.harness),
+        executors: cloneJson(runtime.executors),
+        resources: cloneJson(runtime.resources),
+        artifactActions: cloneJson(runtime.artifactActions)
+    };
+}
+export function readDraftRuntimeBundle(cwd, dir) {
+    const root = ensureGitRepository(cwd);
+    const destinations = readDraftRuntimeJson(root, dir, "destinations.json");
+    if (!destinations.ok)
+        return destinations;
+    const harness = readDraftRuntimeJson(root, dir, "harness.json");
+    if (!harness.ok)
+        return harness;
+    const executors = readDraftRuntimeJson(root, dir, "executors.json");
+    if (!executors.ok)
+        return executors;
+    const resources = readDraftRuntimeJson(root, dir, "resources.json");
+    if (!resources.ok)
+        return resources;
+    const artifactActions = readDraftRuntimeJson(root, dir, "artifact-actions.json");
+    if (!artifactActions.ok)
+        return artifactActions;
+    return ok({
+        destinations: destinations.value,
+        harness: harness.value,
+        executors: executors.value,
+        resources: resources.value,
+        artifactActions: artifactActions.value
+    });
+}
+export function validateDraftRuntimeBundle(previous, request, sourceRuntime) {
+    const sourceBundle = hunsuDraftRuntimeBundleFromRuntime(sourceRuntime);
+    if (stableJson(previous) !== stableJson(sourceBundle)) {
+        return domainStoreError(".hunsu-prev no longer matches the source runtime bundle");
+    }
+    if (stableJson(request.destinations.compatibility) !== stableJson(sourceRuntime.destinations.compatibility)) {
+        return domainStoreError(".hunsu-request/destinations.json compatibility is Local-owned and must not be edited");
+    }
+    try {
+        const requestRuntime = validateRuntimeState({
+            completed: sourceRuntime.completed,
+            destinations: request.destinations,
+            harness: request.harness,
+            executors: request.executors,
+            resources: request.resources,
+            artifactActions: request.artifactActions,
+            currentExecution: sourceRuntime.currentExecution,
+            previousExecution: sourceRuntime.previousExecution,
+            eventLog: sourceRuntime.eventLog
+        }, "draft request runtime");
+        return ok({
+            previous: hunsuDraftRuntimeBundleFromRuntime(sourceRuntime),
+            request: hunsuDraftRuntimeBundleFromRuntime(requestRuntime),
+            requestRuntime
+        });
+    }
+    catch (error) {
+        return domainStoreError(error instanceof Error ? error.message : String(error));
+    }
+}
+export function encodeDraftRuntimeBundleToHunsuFiles(request) {
+    return {
+        [HUNSU_DESTINATIONS_PATH]: encodeHunsuRuntimeFile(request.destinations),
+        [HUNSU_HARNESS_PATH]: encodeHunsuRuntimeFile(request.harness),
+        [HUNSU_EXECUTORS_PATH]: encodeHunsuRuntimeFile(request.executors),
+        [HUNSU_RESOURCES_PATH]: encodeHunsuRuntimeFile(request.resources),
+        [HUNSU_ARTIFACT_ACTIONS_PATH]: encodeHunsuRuntimeFile(request.artifactActions)
+    };
+}
+export function readHunsuRuntimeStateFromWorktree(cwd = process.cwd()) {
+    const root = ensureGitRepository(cwd);
+    if (!HUNSU_RUNTIME_PATHS.every(path => existsSync(join(root, path)))) {
+        return undefined;
+    }
+    return readHunsuRuntimeStateFromSource(path => readFileSync(join(root, path), "utf8"), "worktree", currentHeadCommit(root));
+}
+export function readHunsuRuntimeStateAtRef(cwd = process.cwd(), ref = "HEAD") {
+    const root = ensureGitRepository(cwd);
+    try {
+        const commit = parseCommitSha(git(["rev-parse", "--verify", `${ref}^{commit}`], { cwd: root }).trim());
+        return readHunsuRuntimeStateFromSource(path => git(["show", `${commit}:${path}`], { cwd: root }), commit, commit);
+    }
+    catch (error) {
+        if (error instanceof GitError) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function readReachableHunsuRuntimeStates(cwd = process.cwd()) {
+    const root = ensureGitRepository(cwd);
+    let commits;
+    try {
+        commits = git(["rev-list", "--date-order", "--all", "--", HUNSU_DESTINATIONS_PATH], { cwd: root })
+            .trim()
+            .split(/\r?\n/)
+            .filter(Boolean);
+    }
+    catch (error) {
+        if (error instanceof GitError) {
+            return [];
+        }
+        throw error;
+    }
+    return commits.flatMap(commit => {
+        const commitSha = parseCommitSha(commit);
+        const state = readHunsuRuntimeStateAtRef(root, commitSha);
+        return state ? [{ commit: commitSha, ...state }] : [];
+    });
+}
+export function readPreviousExecutionChain(cwd = process.cwd(), ref) {
+    const root = ensureGitRepository(cwd);
+    const visited = new Set();
+    const chain = [];
+    let nextRef = ref ?? readLatestReachableHunsuRuntimeState(root)?.commit ?? "HEAD";
+    while (nextRef) {
+        let commit;
+        try {
+            commit = parseCommitSha(git(["rev-parse", "--verify", `${nextRef}^{commit}`], { cwd: root }).trim());
+        }
+        catch (error) {
+            if (error instanceof GitError) {
+                break;
+            }
+            throw error;
+        }
+        if (visited.has(commit)) {
+            break;
+        }
+        visited.add(commit);
+        const state = readHunsuRuntimeStateAtRef(root, commit);
+        if (!state || state.runtime.previousExecution.type !== "present") {
+            break;
+        }
+        chain.push({ commit, execution: state.runtime.previousExecution.value });
+        nextRef = state.runtime.previousExecution.value.sourceMoveCommit;
+    }
+    return chain;
+}
+export function hasHunsuRuntimeState(cwd = process.cwd()) {
+    const root = ensureGitRepository(cwd);
+    return readHunsuRuntimeStateFromWorktree(root) !== undefined || readLatestReachableHunsuRuntimeState(root) !== undefined;
+}
+export function readDomainEventRefs(cwd = process.cwd()) {
+    const root = ensureGitRepository(cwd);
+    const output = git(["for-each-ref", `--format=${DOMAIN_EVENT_REF_FORMAT}`, DOMAIN_EVENT_REF_PREFIX], { cwd: root }).trim();
+    if (!output) {
+        return [];
+    }
+    return output
+        .split(/\r?\n/)
+        .map(parseDomainEventRef)
+        .filter(ref => ref.objectType === "blob")
+        .sort((left, right) => left.ordinal - right.ordinal || left.ref.localeCompare(right.ref));
+}
+export function readDomainEventObject(cwd, ref) {
+    const root = ensureGitRepository(cwd);
+    const text = git(["cat-file", "-p", ref.object], { cwd: root });
+    return decodeDomainEventText(text, ref.ref);
+}
+export function decodeDomainEventText(text, ref) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return domainStoreError(`Empty Hunsu domain event object: ${ref}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch (error) {
+        return domainStoreError(`Invalid Hunsu domain event JSON in ${ref}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const validation = validateDomainEvent(parsed);
+    if (!validation.ok) {
+        return domainStoreError(`Invalid Hunsu domain event object in ${ref}: ${validation.error.message}`);
+    }
+    return ok(validation.value);
+}
+function runtimeFromEvents(events, previous, acceptedEvents = [], previousExecutionOverride) {
+    const board = projectDomainEvents(events, "runtime events");
+    const eventLog = {
+        events,
+        updatedAt: acceptedEvents.length > 0 ? new Date().toISOString() : previous?.eventLog.updatedAt
+    };
+    return {
+        completed: completedDestinationsFromEvents(board, previous?.completed, previous ? acceptedEvents : events),
+        destinations: {
+            schema: "hunsu.destinations.v1",
+            order: "queue-head-is-current",
+            destinations: pendingQueueFromBoard(board),
+            compatibility: {
+                events: eventLog.events,
+                updatedAt: eventLog.updatedAt
+            }
+        },
+        ...harnessExecutorsResourcesFilesFromBoard(board, previous),
+        artifactActions: artifactActionsFileFromBoard(board),
+        currentExecution: currentExecutionFromEvents(previous?.currentExecution, acceptedEvents),
+        previousExecution: previousExecutionFromEvents(previous?.previousExecution, acceptedEvents, previousExecutionOverride),
+        eventLog
+    };
+}
+function currentExecutionFromEvents(previous, acceptedEvents) {
+    if (acceptedEvents.some(event => event.type === "HunsuRecorded" || event.type === "LineForkedByHunsu" || event.type === "MoveRecorded")) {
+        return { type: "none" };
+    }
+    return previous ?? { type: "none" };
+}
+function previousExecutionFromEvents(previous, acceptedEvents, override) {
+    if (override) {
+        return override;
+    }
+    if (acceptedEvents.some(event => event.type === "HunsuRecorded" || event.type === "LineForkedByHunsu")) {
+        return { type: "none" };
+    }
+    if (acceptedEvents.some(event => event.type === "MoveRecorded")) {
+        return { type: "none" };
+    }
+    return previous ?? { type: "none" };
+}
+function completedDestinationsFromEvents(board, previous, acceptedEvents) {
+    const entries = previous ? [...previous.entries] : [];
+    for (const event of acceptedEvents) {
+        if (event.type !== "MoveRecorded" || event.move.outcome !== "arrived") {
+            continue;
+        }
+        for (const destinationId of event.move.reachedDestinationIds) {
+            if (entries.some(entry => entry.moveId === event.move.id && entry.destinationId === destinationId)) {
+                continue;
+            }
+            entries.push(completedEntryForMove(board, event.move, destinationId));
+        }
+    }
+    return {
+        schema: "hunsu.completed-destinations.v1",
+        order: "oldest-first-tail-append",
+        entries
+    };
+}
+function completedEntryForMove(board, move, destinationId) {
+    const destination = move.snapshot?.destinations.find(candidate => candidate.id === destinationId)
+        ?? board.destinations.find(candidate => candidate.id === destinationId);
+    return {
+        destinationId,
+        title: destination?.title ?? destinationId,
+        completedAt: move.recordedAt,
+        resultCommit: runtimeCommitRef(move.commit),
+        moveId: move.id,
+        harnessId: "default",
+        digest: {
+            summary: move.summary,
+            evidence: [...move.evidence],
+            risks: move.risks ? [...move.risks] : undefined
+        }
+    };
+}
+function pendingQueueFromBoard(board) {
+    return board.destinations
+        .filter(destination => destination.status !== "reached" && destination.status !== "canceled" && destination.status !== "superseded")
+        .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0) || left.id.localeCompare(right.id));
+}
+function harnessExecutorsResourcesFilesFromBoard(board, previous) {
+    const activeLine = board.lines.findLast(line => line.status === "active") ?? board.lines.at(-1);
+    const activeNode = activeLine ? board.nodes.find(node => node.id === activeLine.currentNodeId) : undefined;
+    const harnessGraph = activeNode?.harnessGraph
+        ?? (previous ? runtimeHarnessGraph(previous) : harnessEntityFromSnapshot(createDefaultHarness()));
+    return {
+        harness: {
+            schema: "hunsu.harness.v1",
+            origins: board.origins.map(origin => ({ ...origin })),
+            harness: {
+                name: "Default Harness",
+                rootTeamId: harnessGraph.rootTeamId,
+                guardrails: harnessGraph.guardrails.map(guardrail => ({ ...guardrail })),
+                lock: activeNode?.harnessLock ? { ...activeNode.harnessLock } : previous?.harness.harness.lock
+            }
+        },
+        executors: {
+            schema: "hunsu.executors.v1",
+            executors: cloneJson(harnessGraph.executors)
+        },
+        resources: {
+            schema: "hunsu.resources.v1",
+            resources: cloneJson(harnessGraph.resources),
+            bindings: board.destinations.map(destination => {
+                const previousBinding = previous?.resources.bindings.find(binding => binding.destinationId === destination.id);
+                return {
+                    destinationId: destination.id,
+                    executorPackageBindings: activeNode?.executorPackageBindings?.map(binding => ({ executorId: binding.executorId, lock: { ...binding.lock } })) ?? previousBinding?.executorPackageBindings,
+                    resourcePackageBindings: activeNode?.resourcePackageBindings?.map(binding => ({ name: binding.name, lock: { ...binding.lock } })) ?? previousBinding?.resourcePackageBindings
+                };
+            })
+        }
+    };
+}
+function artifactActionsFileFromBoard(board) {
+    return {
+        schema: "hunsu.artifact-actions.v1",
+        order: "display-order",
+        actions: board.artifactActions
+            .map(cloneArtifactAction)
+            .sort((left, right) => left.displayOrder - right.displayOrder || String(left.id).localeCompare(String(right.id)))
+    };
+}
+function cloneArtifactAction(action) {
+    return {
+        ...action,
+        env: action.env ? Object.fromEntries(Object.entries(action.env).map(([key, value]) => [key, { ...value }])) : undefined,
+        runner: { ...action.runner },
+        aliases: action.aliases ? Object.fromEntries(Object.entries(action.aliases).map(([key, value]) => [key, { ...value }])) : undefined,
+        evidence: action.evidence ? { ...action.evidence, paths: action.evidence.paths?.slice() } : undefined
+    };
+}
+function readHunsuRuntimeStateFromSource(read, label, selfCommit) {
+    const completed = decodeRequiredRuntimeFile(read, HUNSU_COMPLETED_DESTINATIONS_PATH, label);
+    const destinations = decodeRequiredRuntimeFile(read, HUNSU_DESTINATIONS_PATH, label);
+    const harness = decodeRequiredRuntimeFile(read, HUNSU_HARNESS_PATH, label);
+    const executors = decodeRequiredRuntimeFile(read, HUNSU_EXECUTORS_PATH, label);
+    const resources = decodeRequiredRuntimeFile(read, HUNSU_RESOURCES_PATH, label);
+    const artifactActions = decodeRequiredRuntimeFile(read, HUNSU_ARTIFACT_ACTIONS_PATH, label);
+    if (!completed || !destinations || !harness || !executors || !resources || !artifactActions) {
+        return undefined;
+    }
+    const currentExecution = decodeOptionalRuntimeFile(read, HUNSU_CURRENT_EXECUTION_PATH, label);
+    const previousExecution = decodeOptionalRuntimeFile(read, HUNSU_PREVIOUS_EXECUTION_PATH, label);
+    const runtime = validateRuntimeState({
+        completed: completed.value,
+        destinations: destinations.value,
+        harness: harness.value,
+        executors: executors.value,
+        resources: resources.value,
+        artifactActions: artifactActions.value,
+        currentExecution: currentExecution ? { type: "present", value: currentExecution.value } : { type: "none" },
+        previousExecution: previousExecution ? { type: "present", value: previousExecution.value } : { type: "none" }
+    }, label, selfCommit);
+    return {
+        runtime,
+        checksum: parseRuntimeChecksum(sha256([completed.checksum, destinations.checksum, harness.checksum, executors.checksum, resources.checksum, artifactActions.checksum, currentExecution?.checksum ?? "none", previousExecution?.checksum ?? "none"].join("\n")))
+    };
+}
+function decodeRequiredRuntimeFile(read, path, label) {
+    try {
+        const decoded = decodeRuntimeEnvelope(read(path), `${label}:${path}`, HUNSU_RUNTIME_HEADER);
+        return decoded.ok ? { value: decoded.value.value, checksum: decoded.value.checksum } : unwrapDomainStoreResult(decoded);
+    }
+    catch (error) {
+        if (error instanceof GitError) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function decodeOptionalRuntimeFile(read, path, label) {
+    try {
+        const decoded = decodeRuntimeEnvelope(read(path), `${label}:${path}`, HUNSU_RUNTIME_HEADER);
+        return decoded.ok ? { value: decoded.value.value, checksum: decoded.value.checksum } : unwrapDomainStoreResult(decoded);
+    }
+    catch (error) {
+        if (error instanceof GitError || isMissingFileError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function validateRuntimeState(runtime, source, selfCommit) {
+    if (runtime.completed.schema !== "hunsu.completed-destinations.v1" || runtime.completed.order !== "oldest-first-tail-append" || !Array.isArray(runtime.completed.entries)) {
+        throw new Error(`Invalid completed Destinations runtime file in ${source}`);
+    }
+    if (runtime.destinations.schema !== "hunsu.destinations.v1" || runtime.destinations.order !== "queue-head-is-current" || !Array.isArray(runtime.destinations.destinations)) {
+        throw new Error(`Invalid pending Destinations runtime file in ${source}`);
+    }
+    if (!runtime.destinations.compatibility || !Array.isArray(runtime.destinations.compatibility.events)) {
+        throw new Error(`Invalid pending Destinations compatibility data in ${source}`);
+    }
+    const events = [];
+    for (const [index, event] of runtime.destinations.compatibility.events.entries()) {
+        const validation = validateDomainEvent(resolveRuntimeEventSelfCommit(event, selfCommit));
+        if (!validation.ok) {
+            throw new Error(`Invalid Hunsu runtime event ${index} in ${source}: ${validation.error.message}`);
+        }
+        events.push(validation.value);
+    }
+    const eventLog = {
+        events,
+        updatedAt: typeof runtime.destinations.compatibility.updatedAt === "string"
+            ? runtime.destinations.compatibility.updatedAt
+            : runtime.eventLog?.updatedAt
+    };
+    if (runtime.harness.schema !== "hunsu.harness.v1" || !runtime.harness.harness || typeof runtime.harness.harness.name !== "string") {
+        throw new Error(`Invalid Harness runtime file in ${source}`);
+    }
+    if (Object.prototype.hasOwnProperty.call(runtime.harness.harness, "executors")) {
+        throw new Error(`Invalid Harness runtime file in ${source}: Executor definitions are stored in executors.json`);
+    }
+    if (Object.prototype.hasOwnProperty.call(runtime.harness.harness, "members")) {
+        throw new Error(`Invalid Harness runtime file in ${source}: members is stored in executors.json, not harness.json`);
+    }
+    if (Object.prototype.hasOwnProperty.call(runtime.harness.harness, "plan")) {
+        throw new Error(`Invalid Harness runtime file in ${source}: root Team planner is stored in executors.json, not harness.json`);
+    }
+    if (typeof runtime.harness.harness.rootTeamId !== "string" || !runtime.harness.harness.rootTeamId.trim()) {
+        throw new Error(`Invalid Harness runtime file in ${source}: rootTeamId must reference the locked root Team`);
+    }
+    if (runtime.executors.schema !== "hunsu.executors.v1" || !Array.isArray(runtime.executors.executors)) {
+        throw new Error(`Invalid Executors runtime file in ${source}`);
+    }
+    if (runtime.resources.schema !== "hunsu.resources.v1" || !Array.isArray(runtime.resources.resources) || !Array.isArray(runtime.resources.bindings)) {
+        throw new Error(`Invalid Resources runtime file in ${source}`);
+    }
+    const artifactActions = validateArtifactActionsRuntimeFile(runtime.artifactActions, source);
+    const graph = runtimeHarnessGraph({
+        ...runtime,
+        artifactActions
+    }, source);
+    rootHarnessSnapshot(graph);
+    const currentExecution = validateCurrentExecutionState(runtime.currentExecution, source);
+    const previousExecution = validatePreviousExecutionState(runtime.previousExecution, source, selfCommit);
+    return {
+        completed: runtime.completed,
+        destinations: {
+            ...runtime.destinations,
+            compatibility: { ...runtime.destinations.compatibility, events }
+        },
+        harness: {
+            ...runtime.harness,
+            harness: {
+                name: runtime.harness.harness.name,
+                rootTeamId: graph.rootTeamId,
+                guardrails: graph.guardrails.map(guardrail => ({ ...guardrail })),
+                lock: runtime.harness.harness.lock
+            }
+        },
+        executors: {
+            ...runtime.executors,
+            executors: graph.executors
+        },
+        resources: {
+            ...runtime.resources,
+            resources: graph.resources
+        },
+        artifactActions,
+        currentExecution,
+        previousExecution,
+        eventLog
+    };
+}
+function runtimeHarnessGraph(runtime, source = "runtime") {
+    const graph = validateHarnessEntity({
+        rootTeamId: runtime.harness.harness.rootTeamId,
+        executors: runtime.executors.executors,
+        resources: runtime.resources.resources,
+        guardrails: runtime.harness.harness.guardrails ?? [],
+        artifactActions: runtime.artifactActions.actions
+    }, `${source} Harness graph`);
+    if (!graph.ok) {
+        throw new Error(`Invalid Harness runtime graph in ${source}: ${graph.error.message}`);
+    }
+    return graph.value;
+}
+function validateArtifactActionsRuntimeFile(value, source) {
+    if (value.schema !== "hunsu.artifact-actions.v1" || value.order !== "display-order" || !Array.isArray(value.actions)) {
+        throw new Error(`Invalid Artifact Actions runtime file in ${source}`);
+    }
+    const actions = decodeArtifactActionDefinitionArray(value.actions, "artifactActions.actions");
+    if (!actions.ok) {
+        throw new Error(`Invalid Artifact Actions runtime file in ${source}: ${actions.error.message}`);
+    }
+    return { ...value, actions: actions.value };
+}
+function validateCurrentExecutionState(value, source) {
+    if (!value || value.type === "none") {
+        return { type: "none" };
+    }
+    if (value.type !== "present" || !value.value || value.value.schema !== "hunsu.current-execution.v1") {
+        throw new Error(`Invalid current execution runtime file in ${source}`);
+    }
+    if (!value.value.execution || typeof value.value.execution !== "object") {
+        throw new Error(`Invalid current execution payload in ${source}`);
+    }
+    return value;
+}
+function validatePreviousExecutionState(value, source, selfCommit) {
+    if (!value || value.type === "none") {
+        return { type: "none" };
+    }
+    if (value.type !== "present" || !value.value || value.value.schema !== "hunsu.previous-execution.v1") {
+        throw new Error(`Invalid previous execution runtime file in ${source}`);
+    }
+    if (!value.value.sourceMoveCommit || !value.value.targetMoveId || !value.value.executeId || !value.value.runId || !value.value.lineId) {
+        throw new Error(`Invalid previous execution identity in ${source}`);
+    }
+    if (!value.value.plan || value.value.plan.nodeType !== "PlanNode") {
+        throw new Error(`Invalid previous execution PlanNode in ${source}`);
+    }
+    if (!Array.isArray(value.value.paths)) {
+        throw new Error(`Invalid previous execution PathNode list in ${source}`);
+    }
+    const moveFinalizerCommit = value.value.moveFinalizerCommit;
+    if (isSelfMoveCommitRef(moveFinalizerCommit)) {
+        if (!selfCommit) {
+            throw new Error(`Cannot resolve previous execution self commit in ${source}`);
+        }
+        return { type: "present", value: { ...value.value, moveFinalizerCommit: { type: "external", commit: selfCommit } } };
+    }
+    return value;
+}
+function resolveRuntimeEventSelfCommit(event, selfCommit) {
+    if (event.type !== "MoveRecorded") {
+        return event;
+    }
+    const commit = event.move.commit;
+    if (isSelfMoveCommitRef(commit)) {
+        if (!selfCommit) {
+            throw new Error("Cannot resolve self MOVE commit without containing commit");
+        }
+        return { ...event, move: { ...event.move, commit: selfCommit } };
+    }
+    if (commit === HUNSU_SELF_COMMIT_SENTINEL) {
+        if (!selfCommit) {
+            throw new Error("Cannot resolve self MOVE commit without containing commit");
+        }
+        return { ...event, move: { ...event.move, commit: selfCommit } };
+    }
+    return event;
+}
+function isSelfMoveCommitRef(value) {
+    return Boolean(value && typeof value === "object" && value.type === "self");
+}
+function runtimeCommitRef(value) {
+    if (isSelfMoveCommitRef(value)) {
+        return HUNSU_SELF_COMMIT_REF;
+    }
+    if (value === HUNSU_SELF_COMMIT_SENTINEL) {
+        return HUNSU_SELF_COMMIT_SENTINEL;
+    }
+    return parseCommitSha(String(value));
+}
+function writeHunsuRuntimeState(cwd, runtime, options = {}) {
+    const root = ensureGitRepository(cwd);
+    writeRuntimeFile(root, HUNSU_COMPLETED_DESTINATIONS_PATH, runtime.completed);
+    writeRuntimeFile(root, HUNSU_DESTINATIONS_PATH, destinationsForEncoding(runtime, options.selfCommitMoveIds ?? []));
+    writeRuntimeFile(root, HUNSU_HARNESS_PATH, runtime.harness);
+    writeRuntimeFile(root, HUNSU_EXECUTORS_PATH, runtime.executors);
+    writeRuntimeFile(root, HUNSU_RESOURCES_PATH, runtime.resources);
+    writeRuntimeFile(root, HUNSU_ARTIFACT_ACTIONS_PATH, runtime.artifactActions);
+    writeCurrentExecutionRuntimeFile(root, runtime.currentExecution);
+    writePreviousExecutionRuntimeFile(root, runtime.previousExecution, options.selfCommitMoveIds ?? []);
+}
+function writeRuntimeFile(root, path, value) {
+    const file = join(root, path);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, encodeHunsuRuntimeFile(value).text, "utf8");
+}
+function writeCurrentExecutionRuntimeFile(root, state) {
+    const file = join(root, HUNSU_CURRENT_EXECUTION_PATH);
+    if (state.type === "none") {
+        if (existsSync(file)) {
+            rmSync(file, { force: true });
+        }
+        return;
+    }
+    writeRuntimeFile(root, HUNSU_CURRENT_EXECUTION_PATH, state.value);
+}
+function writePreviousExecutionRuntimeFile(root, state, selfCommitMoveIds) {
+    const file = join(root, HUNSU_PREVIOUS_EXECUTION_PATH);
+    if (state.type === "none") {
+        if (existsSync(file)) {
+            rmSync(file, { force: true });
+        }
+        return;
+    }
+    const value = previousExecutionForEncoding(state.value, selfCommitMoveIds);
+    writeRuntimeFile(root, HUNSU_PREVIOUS_EXECUTION_PATH, value);
+}
+function destinationsForEncoding(runtime, selfCommitMoveIds) {
+    return {
+        ...runtime.destinations,
+        compatibility: {
+            events: runtime.eventLog.events.map(event => eventForEncoding(event, selfCommitMoveIds)),
+            updatedAt: runtime.eventLog.updatedAt
+        }
+    };
+}
+function eventForEncoding(event, selfCommitMoveIds) {
+    if (event.type !== "MoveRecorded" || !selfCommitMoveIds.includes(String(event.move.id))) {
+        return event;
+    }
+    return { ...event, move: { ...event.move, commit: HUNSU_SELF_COMMIT_REF } };
+}
+function previousExecutionForEncoding(value, selfCommitMoveIds) {
+    if (!value.moveFinalizerCommit || value.moveFinalizerCommit.type !== "external" || !selfCommitMoveIds.includes(value.targetMoveId)) {
+        return value;
+    }
+    return { ...value, moveFinalizerCommit: HUNSU_SELF_COMMIT_REF };
+}
+function commitRuntimeStateIfRequested(cwd, commitMessage) {
+    if (!commitMessage) {
+        return;
+    }
+    const paths = stageableRuntimePaths(cwd);
+    if (paths.length === 0) {
+        return;
+    }
+    git(["add", "--all", "--", ...paths], { cwd });
+    const status = git(["status", "--porcelain=v1", "--", ...paths], { cwd }).trim();
+    if (!status) {
+        return;
+    }
+    git(["commit", "--only", "-m", commitMessage, "--", ...paths], { cwd });
+}
+function stageableRuntimePaths(cwd) {
+    return [...HUNSU_RUNTIME_PATHS, HUNSU_CURRENT_EXECUTION_PATH, HUNSU_PREVIOUS_EXECUTION_PATH].filter(path => existsSync(join(cwd, path)) || isTrackedPath(cwd, path));
+}
+function isTrackedPath(cwd, path) {
+    try {
+        git(["ls-files", "--error-unmatch", path], { cwd });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof GitError) {
+            return false;
+        }
+        throw error;
+    }
+}
+function domainStoreFromRuntime(root, runtime, source, eventRefs, checksum, commit) {
+    const events = [...runtime.eventLog.events];
+    return {
+        root,
+        eventRefs,
+        events,
+        board: projectDomainEvents(events, source),
+        runtimePaths: HUNSU_RUNTIME_PATHS,
+        runtime,
+        source,
+        checksum,
+        commit
+    };
+}
+function projectDomainEvents(events, source) {
+    const projected = tryProjectBoard(events);
+    if (!projected.ok) {
+        throw new Error(`Invalid Hunsu domain event stream in ${source}: ${projected.error.message}`);
+    }
+    return projected.value;
+}
+function readLatestReachableHunsuRuntimeState(cwd) {
+    return readReachableHunsuRuntimeStates(cwd)
+        .sort((left, right) => runtimeEventCount(right.runtime) - runtimeEventCount(left.runtime))
+        .at(0);
+}
+function runtimeEventCount(runtime) {
+    return runtime.eventLog.events.length;
+}
+function checksumRuntimeState(runtime) {
+    return parseRuntimeChecksum(sha256([
+        encodeHunsuRuntimeFile(runtime.completed).checksum,
+        encodeHunsuRuntimeFile(destinationsForEncoding(runtime, [])).checksum,
+        encodeHunsuRuntimeFile(runtime.harness).checksum,
+        encodeHunsuRuntimeFile(runtime.executors).checksum,
+        encodeHunsuRuntimeFile(runtime.resources).checksum,
+        encodeHunsuRuntimeFile(runtime.artifactActions).checksum,
+        runtime.currentExecution.type === "present" ? encodeHunsuRuntimeFile(runtime.currentExecution.value).checksum : "none",
+        runtime.previousExecution.type === "present" ? encodeHunsuRuntimeFile(runtime.previousExecution.value).checksum : "none"
+    ].join("\n")));
+}
+function decodeRuntimeEnvelope(text, source, expectedHeader) {
+    const normalized = text.replace(/\r\n/g, "\n");
+    const separator = normalized.indexOf("\n\n");
+    if (separator === -1) {
+        return domainStoreError(`Invalid Hunsu runtime envelope in ${source}`);
+    }
+    const header = normalized.slice(0, separator).split("\n");
+    const payload = normalized.slice(separator + 2).trim();
+    if (header[0] !== expectedHeader) {
+        return domainStoreError(`Invalid Hunsu runtime header in ${source}`);
+    }
+    const metadata = new Map(header.slice(1).map(line => {
+        const index = line.indexOf(":");
+        return index === -1 ? [line.trim(), ""] : [line.slice(0, index).trim(), line.slice(index + 1).trim()];
+    }));
+    if (metadata.get("encoding") !== HUNSU_RUNTIME_ENCODING) {
+        return domainStoreError(`Unsupported Hunsu runtime encoding in ${source}: ${metadata.get("encoding") ?? "missing"}`);
+    }
+    const expectedChecksum = metadata.get("checksum")?.replace(/^sha256:/, "");
+    if (!expectedChecksum) {
+        return domainStoreError(`Missing Hunsu runtime checksum in ${source}`);
+    }
+    let json;
+    try {
+        json = gunzipSync(Buffer.from(payload, "base64url")).toString("utf8");
+    }
+    catch (error) {
+        return domainStoreError(`Invalid Hunsu runtime payload in ${source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const actualChecksum = sha256(json);
+    if (actualChecksum !== expectedChecksum) {
+        return domainStoreError(`Hunsu runtime checksum mismatch in ${source}`);
+    }
+    try {
+        return ok({ value: JSON.parse(json), checksum: parseRuntimeChecksum(actualChecksum) });
+    }
+    catch (error) {
+        return domainStoreError(`Invalid Hunsu runtime JSON in ${source}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function readLegacyHunsuRuntimeStateFromWorktree(cwd) {
+    const root = ensureGitRepository(cwd);
+    const path = join(root, HUNSU_LEGACY_STATE_PATH);
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    const state = unwrapDomainStoreResult(decodeLegacyHunsuRuntimeStateText(readFileSync(path, "utf8"), path));
+    return { state, checksum: checksumLegacyRuntimeState(state) };
+}
+function readLegacyHunsuRuntimeStateAtRef(cwd, ref) {
+    const root = ensureGitRepository(cwd);
+    try {
+        const text = git(["show", `${ref}:${HUNSU_LEGACY_STATE_PATH}`], { cwd: root });
+        const state = unwrapDomainStoreResult(decodeLegacyHunsuRuntimeStateText(text, `${ref}:${HUNSU_LEGACY_STATE_PATH}`));
+        return { state, checksum: checksumLegacyRuntimeState(state) };
+    }
+    catch (error) {
+        if (error instanceof GitError) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function decodeLegacyHunsuRuntimeStateText(text, source) {
+    const decoded = decodeRuntimeEnvelope(text, source, LEGACY_STATE_HEADER);
+    if (!decoded.ok) {
+        return decoded;
+    }
+    const value = decoded.value.value;
+    if (!value || typeof value !== "object") {
+        return domainStoreError(`Invalid legacy Hunsu runtime state JSON in ${source}: expected object`);
+    }
+    const record = value;
+    if (record.version !== 1 || !Array.isArray(record.events)) {
+        return domainStoreError(`Invalid legacy Hunsu runtime state in ${source}`);
+    }
+    const events = [];
+    for (const [index, event] of record.events.entries()) {
+        const validation = validateDomainEvent(event);
+        if (!validation.ok) {
+            return domainStoreError(`Invalid legacy Hunsu runtime state event ${index} in ${source}: ${validation.error.message}`);
+        }
+        events.push(validation.value);
+    }
+    return ok({
+        version: 1,
+        events,
+        ...(typeof record.updatedAt === "string" ? { updatedAt: record.updatedAt } : {})
+    });
+}
+function checksumLegacyRuntimeState(state) {
+    return parseRuntimeChecksum(sha256(`${JSON.stringify(state)}\n`));
+}
+function domainStoreError(message) {
+    return err({ type: "DomainStoreError", message });
+}
+function readDraftRuntimeJson(root, dir, fileName) {
+    const path = join(root, dir, fileName);
+    try {
+        return ok(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch (error) {
+        return domainStoreError(`Cannot read ${dir}/${fileName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function stableJson(value) {
+    return JSON.stringify(sortJson(value));
+}
+function sortJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(sortJson);
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, sortJson(entry)]));
+    }
+    return value;
+}
+function unwrapDomainStoreResult(result) {
+    if (result.ok) {
+        return result.value;
+    }
+    throw new Error(result.error.message);
+}
+function currentHeadCommit(cwd) {
+    try {
+        return parseCommitSha(git(["rev-parse", "--verify", "HEAD^{commit}"], { cwd }).trim());
+    }
+    catch (error) {
+        if (error instanceof GitError) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function isMissingFileError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return "code" in error && error.code === "ENOENT";
+}
+function sha256(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+function parseDomainEventRef(line) {
+    const [ref, object, objectType] = line.split(DOMAIN_EVENT_REF_SEPARATOR);
+    return {
+        ref,
+        object,
+        objectType,
+        ordinal: parseDomainEventOrdinal(ref)
+    };
+}
+function parseDomainEventOrdinal(ref) {
+    const leaf = ref.slice(ref.lastIndexOf("/") + 1);
+    const match = leaf.match(/^E(\d+)(?:-|$)/);
+    return match ? Number.parseInt(match[1], 10) : Number.MAX_SAFE_INTEGER;
+}