@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/core/repository-ledger/fold-repository.js

@@ -0,0 +1,375 @@
+import { isLifecycleCausalAncestor, isTypedLedgerAncestor, ledgerTopologyParents, } from "./traversal.js";
+import { applyFoldEntry, } from "./fold.js";
+function ancestorSet(ledger, start) {
+    const ancestors = new Set();
+    const pending = [start];
+    while (pending.length > 0) {
+        const objectId = pending.pop();
+        if (ancestors.has(objectId))
+            continue;
+        ancestors.add(objectId);
+        const node = ledger.nodes.get(objectId);
+        if (node)
+            pending.push(...ledgerTopologyParents(node));
+    }
+    return ancestors;
+}
+function typedRoots(ledger, start) {
+    const roots = new Set();
+    for (const objectId of ancestorSet(ledger, start)) {
+        const node = ledger.nodes.get(objectId);
+        if (node && node.type !== "lifecycle" && ledgerTopologyParents(node).length === 0)
+            roots.add(objectId);
+    }
+    return roots;
+}
+function lifecycleContracts(ledger, objectIds) {
+    const contracts = new Set();
+    for (const objectId of objectIds) {
+        const node = ledger.nodes.get(objectId);
+        if (node?.type === "transaction")
+            contracts.add(node.contract);
+    }
+    return contracts;
+}
+function analyzeJoinBoundaries(ledger, diseases) {
+    const blocked = new Set();
+    const collisionContracts = new Set();
+    const invalidJoinScopes = new Map();
+    const closureDiseaseIds = new Set(ledger.diseases.map((disease) => disease.objectId));
+    const closureDiseasesByObject = new Map();
+    for (const disease of ledger.diseases) {
+        const rows = closureDiseasesByObject.get(disease.objectId) ?? [];
+        rows.push(disease);
+        closureDiseasesByObject.set(disease.objectId, rows);
+    }
+    for (const objectId of ledger.order) {
+        const node = ledger.nodes.get(objectId);
+        if (!node || (node.type !== "join" && !(node.type === "disease" && node.boundary === "join")))
+            continue;
+        if (node.ledgerParents.length !== 2) {
+            invalidJoinScopes.set(objectId, { kind: "repository" });
+            diseases.push({ objectId, code: "invalid-join", detail: "diseased join does not expose exactly two ledger parents" });
+            continue;
+        }
+        const left = ancestorSet(ledger, node.ledgerParents[0]);
+        const right = ancestorSet(ledger, node.ledgerParents[1]);
+        const common = new Set([...left].filter((candidate) => right.has(candidate)));
+        const leftOnly = new Set([...left].filter((candidate) => !common.has(candidate)));
+        const rightOnly = new Set([...right].filter((candidate) => !common.has(candidate)));
+        const leftContracts = lifecycleContracts(ledger, leftOnly);
+        const rightContracts = lifecycleContracts(ledger, rightOnly);
+        const collisions = [...leftContracts].filter((contract) => rightContracts.has(contract));
+        const leftRoots = typedRoots(ledger, node.ledgerParents[0]);
+        const rightRoots = typedRoots(ledger, node.ledgerParents[1]);
+        const badRoot = leftRoots.size !== 1 || rightRoots.size !== 1 || [...leftRoots][0] !== [...rightRoots][0];
+        const inheritedContractDisease = new Set();
+        let inheritedRepositoryDisease = false;
+        for (const candidate of [...left, ...right]) {
+            const scope = invalidJoinScopes.get(candidate);
+            if (scope?.kind === "repository")
+                inheritedRepositoryDisease = true;
+            if (scope?.kind === "contracts") {
+                for (const contract of scope.contracts)
+                    inheritedContractDisease.add(contract);
+            }
+        }
+        const attributedClosureDisease = new Set();
+        let unattributedClosureDisease = false;
+        for (const candidate of [...left, ...right]) {
+            const candidateNode = ledger.nodes.get(candidate);
+            if (candidateNode === undefined) {
+                unattributedClosureDisease = true;
+                continue;
+            }
+            if (candidateNode.type === "disease") {
+                if (candidateNode.contract === undefined)
+                    unattributedClosureDisease = true;
+                else
+                    attributedClosureDisease.add(candidateNode.contract);
+            }
+            for (const disease of closureDiseasesByObject.get(candidate) ?? []) {
+                if (disease.contract === undefined)
+                    unattributedClosureDisease = true;
+                else
+                    attributedClosureDisease.add(disease.contract);
+            }
+        }
+        const closureDisease = [...left, ...right].some((candidate) => {
+            const candidateNode = ledger.nodes.get(candidate);
+            return candidateNode === undefined || candidateNode.type === "disease" || closureDiseaseIds.has(candidate);
+        });
+        const inheritedDisease = inheritedRepositoryDisease || inheritedContractDisease.size > 0;
+        const structuralInvalid = node.type === "disease" || badRoot || inheritedDisease || closureDisease;
+        if (structuralInvalid) {
+            const repositoryScope = node.type === "disease" || badRoot || inheritedRepositoryDisease || unattributedClosureDisease;
+            if (repositoryScope) {
+                invalidJoinScopes.set(objectId, { kind: "repository" });
+                for (const candidate of [...leftOnly, ...rightOnly])
+                    blocked.add(candidate);
+            }
+            else {
+                invalidJoinScopes.set(objectId, {
+                    kind: "contracts",
+                    contracts: new Set([...inheritedContractDisease, ...attributedClosureDisease]),
+                });
+            }
+            if (badRoot) {
+                diseases.push({ objectId, code: "join-root-divergence", detail: "join parents do not share exactly one typed root" });
+            }
+            else {
+                diseases.push({ objectId, code: "invalid-join", detail: "join typed closure is diseased and selects neither parent side" });
+            }
+        }
+        for (const contract of collisions) {
+            collisionContracts.add(contract);
+            diseases.push({
+                objectId,
+                code: "same-contract-divergence",
+                contract,
+                detail: "join parents contain incomparable lifecycle histories for the same contract",
+            });
+        }
+    }
+    return { blocked, collisionContracts };
+}
+function afterCycleContracts(contracts) {
+    let nextIndex = 0;
+    const indices = new Map();
+    const lowlinks = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const cycles = new Set();
+    const visit = (contract) => {
+        const index = nextIndex++;
+        indices.set(contract, index);
+        lowlinks.set(contract, index);
+        stack.push(contract);
+        onStack.add(contract);
+        const dependencies = contracts.get(contract)?.bind.data.after ?? [];
+        for (const dependency of dependencies) {
+            if (!contracts.has(dependency))
+                continue;
+            if (!indices.has(dependency)) {
+                visit(dependency);
+                lowlinks.set(contract, Math.min(lowlinks.get(contract), lowlinks.get(dependency)));
+            }
+            else if (onStack.has(dependency)) {
+                lowlinks.set(contract, Math.min(lowlinks.get(contract), indices.get(dependency)));
+            }
+        }
+        if (lowlinks.get(contract) !== indices.get(contract))
+            return;
+        const component = [];
+        while (stack.length > 0) {
+            const member = stack.pop();
+            onStack.delete(member);
+            component.push(member);
+            if (member === contract)
+                break;
+        }
+        const selfCycle = component.length === 1 &&
+            (contracts.get(component[0])?.bind.data.after ?? []).includes(component[0]);
+        if (component.length > 1 || selfCycle) {
+            for (const member of component)
+                cycles.add(member);
+        }
+    };
+    for (const contract of contracts.keys()) {
+        if (!indices.has(contract))
+            visit(contract);
+    }
+    return cycles;
+}
+function validateAfterPrerequisites(ledger, contracts, isolatedContracts, diseases) {
+    const containingTransactions = new Map();
+    for (const node of ledger.nodes.values()) {
+        if (node.type !== "transaction")
+            continue;
+        for (const entryObjectId of node.entryObjectIds)
+            containingTransactions.set(entryObjectId, node.objectId);
+    }
+    const cycles = afterCycleContracts(contracts);
+    for (const contract of cycles) {
+        const state = contracts.get(contract);
+        diseases.push({
+            objectId: state.entryObjectIds[0],
+            code: "causal-cycle",
+            contract,
+            detail: `after dependency cycle includes ${[...cycles].sort().join(", ")}`,
+        });
+        contracts.delete(contract);
+        isolatedContracts.add(contract);
+    }
+    const valid = new Set();
+    for (const [contract, state] of contracts) {
+        if (!state.bind.data.after)
+            valid.add(contract);
+    }
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [contract, state] of contracts) {
+            if (valid.has(contract))
+                continue;
+            const bindObjectId = state.entryObjectIds[0];
+            const bindTransaction = containingTransactions.get(bindObjectId);
+            const ready = state.bind.data.after.every((dependency) => {
+                const prerequisite = contracts.get(dependency);
+                const terminalTransaction = prerequisite?.terminalObjectId === null
+                    ? undefined
+                    : containingTransactions.get(prerequisite?.terminalObjectId ?? "");
+                return prerequisite !== undefined &&
+                    valid.has(dependency) &&
+                    prerequisite.terminalObjectId !== null &&
+                    terminalTransaction !== undefined &&
+                    bindTransaction !== undefined &&
+                    isTypedLedgerAncestor(ledger, terminalTransaction, bindTransaction);
+            });
+            if (ready) {
+                valid.add(contract);
+                changed = true;
+            }
+        }
+    }
+    for (const [contract, state] of [...contracts]) {
+        if (!state.bind.data.after || valid.has(contract))
+            continue;
+        const bindObjectId = state.entryObjectIds[0];
+        diseases.push({
+            objectId: bindObjectId,
+            code: "causal-prerequisite",
+            contract,
+            detail: `after prerequisites were not terminal in typed ancestry: ${state.bind.data.after.join(", ")}`,
+        });
+        contracts.delete(contract);
+        isolatedContracts.add(contract);
+    }
+}
+function isolateWorktreePlaceCollisions(contracts, isolatedContracts, diseases) {
+    const occupants = new Map();
+    for (const state of contracts.values()) {
+        if (state.terminalObjectId !== null || state.bind.data.workspace !== "worktree")
+            continue;
+        const states = occupants.get(state.bind.data.place) ?? [];
+        states.push(state);
+        occupants.set(state.bind.data.place, states);
+    }
+    for (const [place, states] of occupants) {
+        if (states.length < 2)
+            continue;
+        const contractsForPlace = states.map((state) => state.contract).sort();
+        for (const state of states) {
+            diseases.push({
+                objectId: state.entryObjectIds[0],
+                code: "worktree-place-collision",
+                contract: state.contract,
+                detail: `worktree place ${place} is assigned to active contracts ${contractsForPlace.join(", ")}`,
+            });
+            contracts.delete(state.contract);
+            isolatedContracts.add(state.contract);
+        }
+    }
+}
+function isolateTaskOwnershipCollisions(contracts, isolatedContracts, diseases) {
+    const owners = new Map();
+    for (const state of contracts.values()) {
+        const terminal = state.terminal;
+        const released = terminal?.kind === "forfeit";
+        if (released)
+            continue;
+        for (const taskId of new Set(state.bind.data.taskIds ?? [])) {
+            const rows = owners.get(taskId) ?? [];
+            rows.push(state);
+            owners.set(taskId, rows);
+        }
+    }
+    for (const [taskId, states] of owners) {
+        if (states.length < 2)
+            continue;
+        const contractsForTask = states.map((state) => state.contract).sort();
+        for (const state of states) {
+            diseases.push({
+                objectId: state.entryObjectIds[0],
+                code: "task-ownership-collision",
+                contract: state.contract,
+                detail: `task ${taskId} is bound by contracts ${contractsForTask.join(", ")}`,
+            });
+            contracts.delete(state.contract);
+            isolatedContracts.add(state.contract);
+        }
+    }
+}
+export function foldRepositoryLedger(ledger) {
+    const diseases = [...ledger.diseases];
+    const { blocked, collisionContracts } = analyzeJoinBoundaries(ledger, diseases);
+    const traversalDiseaseContracts = new Set(ledger.diseases.flatMap((disease) => disease.contract === undefined ? [] : [disease.contract]));
+    const byContract = new Map();
+    const positions = new Map();
+    for (const objectId of ledger.order) {
+        if (blocked.has(objectId))
+            continue;
+        const node = ledger.nodes.get(objectId);
+        if (node?.type !== "transaction")
+            continue;
+        const transactions = byContract.get(node.contract) ?? [];
+        const rows = [];
+        let position = positions.get(node.contract) ?? 0;
+        for (const entryObjectId of node.entryObjectIds) {
+            const entryNode = ledger.nodes.get(entryObjectId);
+            if (entryNode?.type !== "lifecycle")
+                continue;
+            rows.push({ objectId: entryObjectId, entry: entryNode.entry, position });
+            position += 1;
+        }
+        positions.set(node.contract, position);
+        transactions.push({ objectId: node.objectId, rows });
+        byContract.set(node.contract, transactions);
+    }
+    const contracts = new Map();
+    const isolatedContracts = new Set([...collisionContracts, ...traversalDiseaseContracts]);
+    for (const contract of [...byContract.keys()].sort()) {
+        if (isolatedContracts.has(contract))
+            continue;
+        const transactions = byContract.get(contract);
+        const rows = transactions.flatMap((transaction) => transaction.rows);
+        let divergent = false;
+        for (let left = 0; left < rows.length && !divergent; left += 1) {
+            for (let right = left + 1; right < rows.length; right += 1) {
+                const a = rows[left].objectId;
+                const b = rows[right].objectId;
+                if (!isLifecycleCausalAncestor(ledger, a, b) && !isLifecycleCausalAncestor(ledger, b, a)) {
+                    diseases.push({ objectId: b, code: "same-contract-divergence", contract, detail: `incomparable lifecycle entries ${a} and ${b}` });
+                    divergent = true;
+                    break;
+                }
+            }
+        }
+        if (divergent) {
+            isolatedContracts.add(contract);
+            continue;
+        }
+        let state;
+        for (const transaction of transactions) {
+            let staged = state === undefined ? undefined : structuredClone(state);
+            let rejected = false;
+            for (const row of transaction.rows) {
+                const result = applyFoldEntry(staged, row);
+                staged = result.state;
+                if (result.disease) {
+                    diseases.push({ ...result.disease, transactionObjectId: transaction.objectId });
+                    rejected = true;
+                    break;
+                }
+            }
+            if (!rejected)
+                state = staged;
+        }
+        if (state)
+            contracts.set(contract, state);
+    }
+    validateAfterPrerequisites(ledger, contracts, isolatedContracts, diseases);
+    isolateWorktreePlaceCollisions(contracts, isolatedContracts, diseases);
+    isolateTaskOwnershipCollisions(contracts, isolatedContracts, diseases);
+    return { contracts, isolatedContracts, diseases };
+}

package/build/core/repository-ledger/fold.js

@@ -0,0 +1,248 @@
+function illegal(objectId, entry, detail) {
+    return { objectId, code: "illegal-transition", contract: entry.contract, detail };
+}
+function openSegment(state, objectId) {
+    state.segmentOpen = true;
+    state.segments.push({ intent: state.currentIntent, openedBy: objectId, entryObjectIds: [objectId], seal: null });
+}
+function appendToOpenSegment(state, objectId) {
+    if (!state.segmentOpen)
+        return;
+    state.segments.at(-1)?.entryObjectIds.push(objectId);
+}
+function bootstrapFailed(entry) {
+    return entry.data.result.kind !== "exit" || entry.data.result.code !== 0;
+}
+/** Bind-owned automatic paths are admitted and folded with the same ordering. */
+export function bindEffectiveScope(entry) {
+    const taskPaths = (entry.data.taskIds ?? []).map((taskId) => `.keiyaku/tasks/${taskId}.md`);
+    return [...new Set([...entry.data.scope, ...taskPaths])];
+}
+export function applyFoldEntry(state, row) {
+    const { objectId, entry, position } = row;
+    if (!state) {
+        if (entry.kind !== "bind")
+            return { disease: illegal(objectId, entry, `${entry.kind} cannot precede bind`) };
+        return {
+            state: {
+                contract: entry.contract,
+                phase: "active",
+                bind: entry,
+                effectiveScope: bindEffectiveScope(entry),
+                base: entry.data.base,
+                target: entry.data.target,
+                fence: entry.data.base,
+                deliveryHead: entry.data.base,
+                greatestExplicitArc: 0,
+                currentIntent: 0,
+                segmentOpen: true,
+                segments: [{ intent: 0, openedBy: objectId, entryObjectIds: [objectId], seal: null }],
+                sealedBy: null,
+                petition: null,
+                petitionIntent: null,
+                approvedTargetSnapshot: null,
+                verdict: null,
+                terminal: null,
+                terminalObjectId: null,
+                bootstrap: null,
+                bootstrapFailure: "none",
+                entryObjectIds: [objectId],
+                lastAcceptedKind: "bind",
+            },
+        };
+    }
+    const accept = (appendToSegment = true) => {
+        state.entryObjectIds.push(objectId);
+        state.lastAcceptedKind = entry.kind;
+        if (appendToSegment)
+            appendToOpenSegment(state, objectId);
+        return { state };
+    };
+    const reject = (detail) => ({ state, disease: illegal(objectId, entry, detail) });
+    if (state.phase === "claimed" || state.phase === "forfeited") {
+        return reject(`terminal ${state.phase} contract has no lifecycle successor`);
+    }
+    if (state.bootstrapFailure === "interrupted") {
+        return reject("failed bootstrap must be followed immediately by bind-failed forfeit");
+    }
+    if (state.bootstrapFailure === "awaiting-forfeit") {
+        if (entry.kind === "forfeit" &&
+            entry.data.reason === "bind-failed" &&
+            position === state.bootstrap.position + 1) {
+            state.phase = "forfeited";
+            state.deliveryHead = entry.data.finalHead;
+            state.terminal = entry;
+            state.terminalObjectId = objectId;
+            state.bootstrapFailure = "none";
+            return accept(false);
+        }
+        state.bootstrapFailure = "interrupted";
+        return reject("failed bootstrap must be followed immediately by bind-failed forfeit");
+    }
+    if (entry.kind === "bind")
+        return reject("bind may occur only once");
+    if (entry.kind === "bootstrap") {
+        if (position !== 1 || state.entryObjectIds.length !== 1) {
+            return reject("bootstrap must immediately follow bind");
+        }
+        if (state.bind.data.workspace !== "worktree" || !state.bind.data.bootstrap) {
+            return reject("bootstrap without bind plan");
+        }
+        const failed = bootstrapFailed(entry);
+        state.bootstrap = { objectId, position, result: entry.data.result, failed };
+        if (failed)
+            state.bootstrapFailure = "awaiting-forfeit";
+        return accept();
+    }
+    if (entry.kind === "amend") {
+        const extendScope = () => {
+            if (entry.data.scopeDelta)
+                state.effectiveScope.push(...entry.data.scopeDelta.add);
+        };
+        if (state.phase === "active" && state.segmentOpen) {
+            extendScope();
+            return accept();
+        }
+        if (state.phase === "awaiting-verdict" || state.phase === "approved") {
+            state.phase = "active";
+            state.sealedBy = null;
+            state.petition = null;
+            state.petitionIntent = null;
+            state.approvedTargetSnapshot = null;
+            state.verdict = null;
+            openSegment(state, objectId);
+            extendScope();
+            return accept(false);
+        }
+        return reject("amend requires an active segment or a petitioned state");
+    }
+    if (entry.kind === "seal") {
+        if (state.phase !== "active" || !state.segmentOpen)
+            return reject("seal requires an active open segment");
+        if (entry.data.arc !== state.currentIntent)
+            return reject("seal arc does not match current intent");
+        if (entry.data.oldFence !== state.fence)
+            return reject("seal oldFence does not continue the folded fence");
+        const segment = state.segments.at(-1);
+        segment.entryObjectIds.push(objectId);
+        segment.seal = {
+            objectId,
+            sealedBy: entry.data.sealedBy,
+            oldFence: entry.data.oldFence,
+            receipts: [...entry.data.receipts],
+            newFence: entry.data.newFence,
+            diffstat: { ...entry.data.diffstat },
+            scopeAudit: { violations: [...entry.data.scopeAudit.violations] },
+        };
+        state.phase = "sealed";
+        state.segmentOpen = false;
+        state.sealedBy = entry.data.sealedBy;
+        state.fence = entry.data.newFence;
+        state.deliveryHead = entry.data.newFence;
+        return accept(false);
+    }
+    if (entry.kind === "arc") {
+        if (state.phase !== "sealed" || state.sealedBy !== "arc")
+            return reject("arc must consume an arc seal");
+        if (entry.data.arc !== state.greatestExplicitArc + 1)
+            return reject("explicit arcs must increase by exactly one");
+        state.greatestExplicitArc = entry.data.arc;
+        state.currentIntent = entry.data.arc;
+        state.phase = "active";
+        state.sealedBy = null;
+        openSegment(state, objectId);
+        return accept(false);
+    }
+    if (entry.kind === "renew") {
+        if (state.phase !== "sealed" || state.sealedBy !== "renew")
+            return reject("renew must consume a renew seal");
+        const seal = state.segments.at(-1)?.seal;
+        if (!seal)
+            return reject("renew seal facts are missing");
+        const replacedHead = seal.receipts.at(-1) ?? seal.oldFence;
+        if (entry.data.oldBase !== state.base || entry.data.oldHead !== replacedHead) {
+            return reject("renew old coordinates do not match folded coordinates");
+        }
+        if (entry.data.newHead !== seal.newFence)
+            return reject("renew newHead does not match its seal fence");
+        state.base = entry.data.newBase;
+        state.fence = entry.data.newHead;
+        state.deliveryHead = entry.data.newHead;
+        state.phase = "active";
+        state.sealedBy = null;
+        openSegment(state, objectId);
+        return accept(false);
+    }
+    if (entry.kind === "petition") {
+        const currentSegment = state.segments.at(-1);
+        const consumesImmediateRenewSeal = state.phase === "active"
+            && state.segmentOpen
+            && state.lastAcceptedKind === "renew"
+            && currentSegment?.seal === null
+            && currentSegment.entryObjectIds.length === 1
+            && state.entryObjectIds.at(-1) === currentSegment.openedBy;
+        if (state.phase !== "sealed" && !consumesImmediateRenewSeal) {
+            return reject("petition must consume a seal");
+        }
+        if (entry.data.target !== state.target)
+            return reject("petition target does not match bind target");
+        state.phase = "awaiting-verdict";
+        state.sealedBy = null;
+        state.petition = entry;
+        state.petitionIntent = entry.data.intent;
+        state.approvedTargetSnapshot = null;
+        state.verdict = null;
+        return accept(false);
+    }
+    if (entry.kind === "verdict") {
+        if (state.phase !== "awaiting-verdict" || !state.petition)
+            return reject("verdict requires a pending petition");
+        state.verdict = entry;
+        if (entry.data.result === "approved") {
+            state.phase = "approved";
+            const petitionData = state.petition.data;
+            state.approvedTargetSnapshot = petitionData.intent === "claim"
+                ? { target: petitionData.target, targetHead: petitionData.targetHead }
+                : null;
+            return accept(false);
+        }
+        state.phase = "active";
+        state.petition = null;
+        state.petitionIntent = null;
+        state.approvedTargetSnapshot = null;
+        state.verdict = null;
+        openSegment(state, objectId);
+        return accept(false);
+    }
+    if (entry.kind === "claim") {
+        const petitionData = state.petition?.data;
+        if (state.phase !== "approved" || !petitionData || petitionData.intent !== "claim") {
+            return reject("claim requires an approved claim petition");
+        }
+        if (entry.data.target !== state.target ||
+            entry.data.base !== state.base ||
+            entry.data.targetHead !== petitionData.targetHead ||
+            entry.data.deliveryHead !== state.deliveryHead)
+            return reject("claim coordinates do not match folded petition coordinates");
+        state.phase = "claimed";
+        state.terminal = entry;
+        state.terminalObjectId = objectId;
+        return accept(false);
+    }
+    if (entry.kind === "forfeit") {
+        if (entry.data.reason === "bind-failed")
+            return reject("bind-failed forfeit requires an immediately preceding failed bootstrap");
+        if (state.phase === "awaiting-verdict") {
+            return reject("manual forfeit cannot bypass a pending settlement");
+        }
+        if (state.phase === "approved" && state.petition?.data.intent !== "forfeit") {
+            return reject("approved settlement permits forfeit only for forfeit intent");
+        }
+        state.phase = "forfeited";
+        state.deliveryHead = entry.data.finalHead;
+        state.terminal = entry;
+        state.terminalObjectId = objectId;
+        return accept(false);
+    }
+    return reject(`unsupported transition ${entry.kind}`);
+}