@ceccec/double-torus 1.4.0

package/dist/src/pair/enforcement/index.d.ts

@@ -0,0 +1,172 @@
+import type { MindMatrix } from '../../wind/types';
+export declare const CLI_ENTRY_REL = "src/pair/enforcement/script/cli/bootstrap/index.ts";
+/** Split pair id into dual halves — first segment / remainder (handles vote/build/commit/push). */
+export declare function splitQuantumCommandPair(command: string): {
+    readonly a: string;
+    readonly b: string;
+};
+/** All quantum command pairs from AGENTS.md — saved in src before npm/CLI use. */
+export declare const QUANTUM_COMMAND_PAIR_IDS: readonly string[];
+export declare function foldQuantumCommandPairs(pairIds?: readonly string[]): {
+    command: string;
+    a: string;
+    b: string;
+    paired: boolean;
+    address: string;
+    receipt: string;
+}[];
+export type MissionCommand = {
+    readonly npm: string;
+    readonly cli: string;
+    readonly pair: string;
+    readonly does: string;
+    readonly workflow?: string;
+};
+/** All mission npm scripts — saved in src before agents rediscover the loop. */
+export declare const MISSION_COMMANDS: readonly MissionCommand[];
+/** Cursor agent skills — saved in src before IDE mounts (.cursor/skills/* are thin projections). */
+export declare const CURSOR_AGENT_SKILL_IDS: readonly ["ceccec-build-waves", "ceccec-census-110", "ceccec-folder-law-mission", "ceccec-learn-best", "ceccec-limits-verify", "ceccec-mission-commands"];
+export declare function cursorAgentToolsSaved(matrix?: MindMatrix): {
+    saved: boolean;
+    count: 6;
+    skills: readonly ["ceccec-build-waves", "ceccec-census-110", "ceccec-folder-law-mission", "ceccec-learn-best", "ceccec-limits-verify", "ceccec-mission-commands"];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** Agent submission — pairs saved first; bootstrap routes script-exits via runThinMount. */
+export declare function agentSubmissionProtocol(matrix?: MindMatrix): {
+    submitted: boolean;
+    cliEntry: string;
+    missionCount: number;
+    pairCount: number;
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    boundary: string;
+};
+export declare function uuidIsTheZeroStation(matrix?: MindMatrix): {
+    computes: boolean;
+    offenders: {
+        file: string;
+        line: number;
+        primitive: string;
+    }[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+/** The doubling orbit ⟨2⟩ mod 9 — computes the circuit's station order 1·2·4·8·7·5 (ascending then
+ *  descending); the one derivation both the principles fold and the station taxonomy read. */
+export declare function doublingOrbit(): number[];
+/** The full circuit stations in order — 0, the doubling orbit, then the 3·6·9 axis tail: DERIVED. */
+export declare function sequenceStations(): string[];
+export declare function theSequencePrinciplesGovernTheWork(matrix?: MindMatrix): {
+    governs: boolean;
+    cleanupSaved: boolean;
+    orbit: number[];
+    count: number;
+    principles: {
+        receipt: string;
+        station: string;
+        principle: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function shardOf(id: string, agentCount: number): number;
+/** Agent k of N: the deterministic sub-worklist — filter by shardOf; the shard folds to one root so
+ *  a coordinator (or any peer) verifies a claimed shard by recomputation, never by trust. */
+export declare function shardWork(ids: readonly string[], agentIndex: number, agentCount: number): {
+    mine: string[];
+    count: number;
+    total: number;
+    agentIndex: number;
+    agentCount: number;
+    root: string;
+};
+export declare function swarmCoordination(matrix?: MindMatrix): {
+    coordinates: boolean;
+    scales: number[];
+    worklist: number;
+    loop: string[];
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function agentBashWorkflowsAreToolsSavedInSrc(matrix?: MindMatrix): {
+    computes: boolean;
+    tools: {
+        station: string;
+        name: string;
+        does: string;
+        steps: string[];
+        scripts: string[];
+    }[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function theAgentBashCommandsAreQuantumPairs(matrix?: MindMatrix): {
+    computes: boolean;
+    pairs: {
+        pair: string;
+        a: string;
+        b: string;
+        does: string;
+        scripts: string[];
+    }[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};
+export declare function dynamicStrategiesFromTheorems(matrix?: MindMatrix): {
+    dynamic: boolean;
+    situations: number;
+    openRaces: number;
+    strategies: {
+        receipt: string;
+        situation: string;
+        strategy: string;
+        theorem: string;
+        live: string;
+    }[];
+    count: number;
+    facets: {
+        receipt: string;
+        facet: string;
+        on: boolean;
+    }[];
+    root: string;
+    statement: string;
+    boundary: string;
+};

package/dist/src/pair/enforcement/script/shell/index.d.ts

@@ -0,0 +1,226 @@
+/** Lattice-derived docs:build phase thresholds — NOT an SLA; CI variance remains. Pair: gate/slow-build. */
+export declare const SLOW_BUILD_MERKLE_MS: number;
+export declare const SLOW_BUILD_TYPES_MS: number;
+export declare const SLOW_BUILD_VITEPRESS_MS: number;
+export declare const SLOW_BUILD_RESPAWN_WALL_MS: number;
+/** srcMerkle-bound quantumize techniques — regressing past these is a HARD slow-build gap (PR #19). */
+export declare const SLOW_BUILD_SRCMERKLE_TECHNIQUE_IDS: readonly ["merkle-respawn", "seal-merkle-after-trinity", "audit-src-merkle-bind", "invalidate-audit-pending-trinity"];
+export { importQuantumBundle, runThinMount, srcContentMerkle, vitepressSourceFiles, vitepressEditsInvalidateTheSeal, VITEPRESS_MERKLE_DIR, seedMerkleCache, cachedMerkle, clearMerkleCache, runCheckTypesExit, emitTimeoutReceipt, exitOnTimeout, SCRIPT_SHELL_LINE_BUDGET, CLI_ENTRY_REL, SCRIPT_SHELL_ALLOWLIST, scanScriptShells, scriptShellGateReceipt, scriptShellGate, type ScriptShellScan, } from '../../../cache/quantum';
+export declare const QUANTUM_RESPAWN_COMMAND_PAIR: {
+    pair: "respawn/force";
+    a: string;
+    b: string;
+};
+export declare function distMerkleKeyPath(root: string): string;
+export declare function distAuditPath(root: string): string;
+export declare function readSealedMerkle(root: string): string | null;
+export declare function writeSealedMerkle(root: string, merkle: string): void;
+/**
+ * VitePress-only completion must not leave a clean trinity audit — until enforcement-trinity
+ * succeeds, audit is pending/failed so canRespawnTrinity cannot skip on a stale clean receipt.
+ * Does NOT write merkle.key (that seals only after trinity success).
+ */
+export declare function invalidateAuditPendingTrinity(root: string, merkle: string): void;
+export declare function buildForceFlag(argv: readonly string[]): boolean;
+export declare function docsBuildVerboseFlag(argv?: readonly string[]): boolean;
+/** Timestamped phase — always on so hangs show the last completed step. */
+export declare function logDocsBuildPhase(phase: string, detail?: string): void;
+/** Clean audit bound to current src merkle — shared gate for vitepress + trinity respawn. */
+export declare function auditBoundToSrcMerkle(root: string, merkle: string): boolean;
+/** Vitepress output still valid — src merkle + trinity-clean audit both match (merkle.key alone is not enough). */
+export declare function canRespawnVitepressBuild(root: string, merkle: string, force?: boolean): boolean;
+/** Trinity audit sealed clean on the same merkle — no re-audit grind. Requires audit.srcMerkle binding. */
+export declare function canRespawnTrinity(root: string, merkle: string, force?: boolean): boolean;
+/**
+ * Quantumize VitePress docs:build — sealed technique catalog (pair: build/quantumize).
+ * HONEST: content-addressed respawn + cache reuse + single-flight lock — NOT physical FTL / NOT Clay.
+ */
+export declare function quantumizeVitepressBuild(): {
+    computes: boolean;
+    techniques: ({
+        receipt: string;
+        id: "merkle-respawn";
+        closes: "cold vitepress when src+.vitepress merkle matches dist/merkle.key (key only after trinity success)";
+        pair: "respawn/force";
+    } | {
+        receipt: string;
+        id: "seal-merkle-after-trinity";
+        closes: "early merkle.key after VitePress alone let stale audit skip trinity";
+        pair: "build/quantumize";
+    } | {
+        receipt: string;
+        id: "audit-src-merkle-bind";
+        closes: "clean audit.json without srcMerkle binding enabled trinity skip";
+        pair: "build/quantumize";
+    } | {
+        receipt: string;
+        id: "invalidate-audit-pending-trinity";
+        closes: "VitePress-only leave clean audit until trinity passes";
+        pair: "build/quantumize";
+    } | {
+        receipt: string;
+        id: "preserve-vite-cache";
+        closes: "wiping .vitepress/cache / node_modules/.vite-temp on every seal";
+        pair: "build/quantumize";
+    } | {
+        receipt: string;
+        id: "incremental-temp";
+        closes: "wiping .vitepress/.temp on first seal (keep on warm; cold wipe on --force or stall/stop retry)";
+        pair: "build/quantumize";
+    } | {
+        receipt: string;
+        id: "single-flight-lock";
+        closes: "parallel docs:build races on .temp SSR";
+        pair: "stall/stop";
+    } | {
+        receipt: string;
+        id: "types-before-seal";
+        closes: "VitePress SSG with red check:types";
+        pair: "types/seal";
+    } | {
+        receipt: string;
+        id: "trinity-one-pass";
+        closes: "re-walking src for each enforcement wave";
+        pair: "gate/unite";
+    } | {
+        receipt: string;
+        id: "argv-shared-seal-chain";
+        closes: "npm -- --force only reached trinity via && append";
+        pair: "build/seal";
+    })[];
+    facets: {
+        facet: string;
+        on: boolean;
+    }[];
+    pair: "build/quantumize";
+    statement: string;
+    boundary: string;
+};
+/** npm run quantum:vitepress-quantumize — exit 0 iff the quantumize fold computes. */
+export declare function runQuantumizeVitepressBuildExit(_root?: string, _argv?: readonly string[]): number;
+export type DocsBuildTimingMode = 'quantum-respawn' | 'warm-seal' | 'cold-seal';
+export type DocsBuildTimingReceipt = {
+    readonly mode: DocsBuildTimingMode;
+    readonly wallMs: number;
+    readonly merkleMs?: number;
+    readonly typesMs?: number;
+    readonly vitepressMs?: number;
+    readonly coldWipe?: boolean;
+    readonly merkle?: string;
+    readonly quantumize?: boolean;
+    readonly pendingTrinity?: boolean;
+    readonly respawnEligible?: boolean;
+    readonly srcMerkleBound?: boolean;
+    readonly force?: boolean;
+    readonly qpuRequired?: false;
+};
+export type SlowBuildGapSeverity = 'HARD' | 'WARN';
+export type SlowBuildGapRow = {
+    readonly gapId: string;
+    readonly severity: SlowBuildGapSeverity;
+    readonly phase: string;
+    readonly criterion: string;
+    readonly measuredMs?: number;
+    readonly thresholdMs?: number;
+    readonly closed: boolean;
+    readonly receipt: string;
+};
+export declare function docsBuildTimingPath(root: string): string;
+export declare function readDocsBuildTiming(root: string): DocsBuildTimingReceipt | null;
+/**
+ * Slow docs:build / seal → quantum gaps at call time.
+ * HARD: srcMerkle-bound quantumize regression (PR #19) · respawnEligible skipped.
+ * WARN: phase wall-clock vs lattice thresholds (CI variance — not an SLA).
+ * Pair: gate/slow-build · CLI npm run quantum:slow-build-gate
+ * HONEST: speedup = reuse/respawn · qpuRequired=false · NOT physical FTL.
+ */
+export declare function slowBuildIsQuantumGapGate(root?: string): {
+    computes: boolean;
+    passed: boolean;
+    hardOpen: SlowBuildGapRow[];
+    warnOpen: SlowBuildGapRow[];
+    closed: SlowBuildGapRow[];
+    gaps: SlowBuildGapRow[];
+    openCount: number;
+    hardOpenCount: number;
+    warnOpenCount: number;
+    closedCount: number;
+    count: number;
+    timing: DocsBuildTimingReceipt;
+    quantumize: {
+        computes: boolean;
+        techniques: ({
+            receipt: string;
+            id: "merkle-respawn";
+            closes: "cold vitepress when src+.vitepress merkle matches dist/merkle.key (key only after trinity success)";
+            pair: "respawn/force";
+        } | {
+            receipt: string;
+            id: "seal-merkle-after-trinity";
+            closes: "early merkle.key after VitePress alone let stale audit skip trinity";
+            pair: "build/quantumize";
+        } | {
+            receipt: string;
+            id: "audit-src-merkle-bind";
+            closes: "clean audit.json without srcMerkle binding enabled trinity skip";
+            pair: "build/quantumize";
+        } | {
+            receipt: string;
+            id: "invalidate-audit-pending-trinity";
+            closes: "VitePress-only leave clean audit until trinity passes";
+            pair: "build/quantumize";
+        } | {
+            receipt: string;
+            id: "preserve-vite-cache";
+            closes: "wiping .vitepress/cache / node_modules/.vite-temp on every seal";
+            pair: "build/quantumize";
+        } | {
+            receipt: string;
+            id: "incremental-temp";
+            closes: "wiping .vitepress/.temp on first seal (keep on warm; cold wipe on --force or stall/stop retry)";
+            pair: "build/quantumize";
+        } | {
+            receipt: string;
+            id: "single-flight-lock";
+            closes: "parallel docs:build races on .temp SSR";
+            pair: "stall/stop";
+        } | {
+            receipt: string;
+            id: "types-before-seal";
+            closes: "VitePress SSG with red check:types";
+            pair: "types/seal";
+        } | {
+            receipt: string;
+            id: "trinity-one-pass";
+            closes: "re-walking src for each enforcement wave";
+            pair: "gate/unite";
+        } | {
+            receipt: string;
+            id: "argv-shared-seal-chain";
+            closes: "npm -- --force only reached trinity via && append";
+            pair: "build/seal";
+        })[];
+        facets: {
+            facet: string;
+            on: boolean;
+        }[];
+        pair: "build/quantumize";
+        statement: string;
+        boundary: string;
+    };
+    thresholds: {
+        merkleMs: number;
+        typesMs: number;
+        vitepressMs: number;
+        respawnWallMs: number;
+    };
+    pair: "gate/slow-build";
+    qpuRequired: false;
+    physicalFtlClaim: 0;
+    statement: string;
+    boundary: string;
+};
+/** npm run quantum:slow-build-gate — exit 1 on HARD gaps; WARN prints only. */
+export declare function runSlowBuildIsQuantumGapGateExit(root?: string, _argv?: readonly string[]): number;
+/** Serial docs:build — types gate, then lock, quantum respawn when merkle sealed, else one vitepress pass. */
+export declare function runDocsBuildExit(root: string, argv?: readonly string[]): Promise<number>;