looply-cli 0.0.0-stage → 0.2.0

package/dist/integration-runtime.d.ts

@@ -0,0 +1,458 @@
+import { GitDriver } from './git-driver';
+import { type DeliveredClaim, type IntegratedReceipt, type RequiredProfile, type RequirementLink } from '@looply/core';
+/**
+ * THE INTEGRATION QUEUE — THE PRODUCTION CALLER PHASE 5 NEVER HAD.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 `canIntegrate` AND `cutFrom` WERE WRITTEN, SPECCED, AND CALLED BY NOTHING.
+ *
+ * MEASURED before this file existed, with `run.integration` fully enabled and a
+ * run's base two commits behind: `baseFreshness` answered `{kind:'current'}`,
+ * `cutFrom` answered `null`, and `refExists('looply/integration')` was false.
+ * Nothing in the product ever created the ref, so the whole phase — the
+ * staleness check included — was inert. This is the runtime that makes it real,
+ * and nothing more than that.
+ *
+ * ⚠️ IT IS NOT A SECOND SCHEDULER. It decides nothing about which goal runs; it
+ * answers one question, once per invocation, about work that has already
+ * finished: may this branch go in, and did it pass the checks at the commit
+ * that would actually be published. The coordinator still schedules.
+ *
+ * ⚠️ FAST-FORWARD OR NOTHING, so there is no candidate to construct. The commit
+ * that would be published IS the run's own commit. That is why this file needs
+ * no `merge` verb: a candidate built by merging would be a different tree from
+ * the one the run's two keys signed, and "auto-resolving a merge conflict" is
+ * listed under Never.
+ */
+/** One durable line per attempt. Append-only, for the same reason every ledger here is. */
+export interface IntegrationAttempt {
+    readonly attemptId: string;
+    readonly at: string;
+    readonly goalId?: string;
+    readonly runId?: string;
+    /** The branch offered, and the commit at its tip when it was offered. */
+    readonly branch: string;
+    readonly commitSha: string;
+    /** What integration was when this candidate was validated. */
+    readonly expectedBase: string | null;
+    /** The commit the checks actually ran against — for a fast-forward, the tip. */
+    readonly candidateSha: string;
+    readonly verdict: 'fast-forward' | 'needs-rebase' | 'nothing';
+    readonly checks?: {
+        readonly name: string;
+        readonly ok: boolean;
+        readonly detail: string;
+    }[];
+    /** Absent until publication is attempted; `false` when the base moved underneath. */
+    readonly published?: {
+        readonly ref: string;
+        readonly from: string | null;
+        readonly to: string;
+    };
+    /**
+     * AN EVALUATOR VERDICT THIS ATTEMPT OWES AND DOES NOT HAVE.
+     *
+     * 🔴 STRUCTURED, BECAUSE IT WAS ONLY EVER A SENTENCE. When a refused
+     * candidate is carried onto the integration branch, `replayDecision` declines
+     * to carry the model's verdict across — deliberately, because the contract it
+     * was formed against has moved or because nothing was established about it at
+     * all. The lane then re-gates the carried commit and publishes it on green,
+     * which is right and which `OWNER_CHARTER.md` §4 explicitly asks for
+     * ("fresh gates always apply to the new tree").
+     *
+     * What was missing is the other half of the same clause: *"a ledger warning
+     * alone does not satisfy a required review"*. The fact that no verdict was
+     * taken lived only inside `because`, so nothing could ask which published
+     * candidates owe one without matching words in a sentence written for a
+     * person. This is that fact, in a shape something can read.
+     *
+     * ⚠️ IT IS NOT A REFUSAL AND MUST NOT BECOME ONE. Refusing to publish would
+     * be stricter than the product's own answer to the same question, and inert
+     * in any project with no graph — `revalidationVerdict` answers `unmeasurable`
+     * there every time, so every carried change would be refused and the measured
+     * loss this feature exists to fix would stand. The charter also says not to
+     * freeze working replay. The obligation is recorded; publication is unchanged.
+     */
+    readonly reviewOwed?: {
+        /** `revalidate` — a contract moved. `unmeasurable` — nothing was established. */
+        readonly reason: 'revalidate' | 'unmeasurable';
+        readonly because: string;
+    };
+    /**
+     * THE VERIFICATION ENVIRONMENT THESE CHECKS RAN UNDER — Rule #1's receipt half.
+     *
+     * 🔴 NORMALIZED FACTS *AND* A DIGEST, NEVER THE DIGEST ALONE. The digest is an
+     * identity for quoting and dedup; nothing compares two of them to decide
+     * anything, because that would make a node patch bump invalidate every
+     * receipt. A person reading a refusal needs "runtime was node@20.20.0 and the
+     * specification wanted node@22", which only the facts can say.
+     *
+     * ⚠️ OPTIONAL, AND ABSENT IS THE WHOLE BACKWARD-COMPATIBILITY GUARANTEE. A
+     * `check` that returns a bare array — every fixture in the suite, and any
+     * caller predating this — records no environment and behaves exactly as
+     * before.
+     */
+    readonly environment?: {
+        readonly facts: Readonly<Record<string, string | null>>;
+        readonly digest: string;
+    };
+    /**
+     * An interlock tripped and NO step ran.
+     *
+     * ⚠️ RECORDED BECAUSE IT WAS COMPUTED AND DISCARDED. `runDoctorGate` returns
+     * `{abort, steps: [], …}` when an interlock fires, and the lane already fails
+     * closed on the empty check set ("no required check ran"). What it could not
+     * say was WHY there were none, which is the difference between a misconfigured
+     * project and a candidate that touched a forbidden path.
+     */
+    readonly abort?: {
+        readonly code: number;
+        readonly reason: string;
+    };
+    /**
+     * WHICH SOURCE REQUIREMENTS THIS INTEGRATED REVISION MAY BE SAID TO MEET.
+     *
+     * 🔴 REGENERATED HERE, NEVER CARRIED. The candidate brings a CLAIM — what each
+     * item said it served — and this is the verdict, computed from the gate that
+     * ran against the commit this attempt publishes, under the environment above,
+     * against the goal's identity as the lane finds it now.
+     *
+     * ⚠️ ABSENT FOR EVERY PROJECT THAT HOLDS NO CLAIMS, which is most of them and
+     * is not a refusal.
+     */
+    readonly requirements?: IntegratedReceipt;
+    /**
+     * PROGRAMME MODE ONLY: the checks that were red on the base and are still red
+     * here, that no rule made this candidate answer for — admitted, and NOT MET.
+     *
+     * ⚠️ A RECORD, NEVER A CREDIT. `checks` still says they failed, and
+     * `integratedReceipt` reads them as failed exactly as it always has. Absent
+     * whenever there were none, and always absent in simple mode. See
+     * `LaneAdmission`.
+     */
+    readonly notYetMet?: readonly string[];
+    /**
+     * THE REPLAY BRANCH THAT CARRIED THIS REFUSED CANDIDATE, on the `needs-rebase`
+     * attempt that handed it over. A structured fact, so a reader can follow the
+     * run branch to its replay's own answer (`publicationOf`) instead of matching
+     * words inside `because` — which is all it could do before (F21).
+     */
+    readonly replayedAs?: string;
+    /**
+     * AN OWED VERDICT THE OWNER'S POLICY SETTLED, on the attempt that published a
+     * replay: programme mode, the carried change touched no file the base had moved,
+     * and the lane published it (so every required, claimed and previously-green check
+     * passed; only checks not yet met by anyone stayed red). Recorded INSTEAD of
+     * `reviewOwed`, never silently (owner decision 2026-09-24, F23).
+     */
+    readonly reviewSettled?: {
+        readonly by: 'owner-policy';
+        readonly because: string;
+    };
+    readonly because?: string;
+}
+/** One check the lane ran against a candidate. */
+export interface LaneCheck {
+    readonly name: string;
+    readonly ok: boolean;
+    readonly detail: string;
+    /**
+     * The check reached NO VERDICT: it never started (`did-not-run` — no toolchain, a containment
+     * launch that failed) or it ran out of time (`timed-out`). Still `ok: false`, so every existing
+     * reader refuses exactly as before; what it must never be is evidence that a check was RED —
+     * programme admission reads "red on the base" as permission, and a check that never ran is not
+     * that. Absent for a check that ran to an exit.
+     */
+    readonly inconclusive?: 'did-not-run' | 'timed-out';
+}
+/**
+ * What a candidate's gate pass reports, when the runner has more to say than a
+ * list of checks.
+ *
+ * ⚠️ A UNION ARM RATHER THAN A REPLACEMENT, DELIBERATELY. `IntegrationDeps.check`
+ * accepts this OR a bare `LaneCheck[]`, so the seven existing fixtures keep
+ * compiling untouched and no behaviour changes for a caller that returns an
+ * array. The cost is a dependency that admits two shapes; the alternative was a
+ * wider diff across suites this packet otherwise does not touch. Both arms are
+ * pinned by tests.
+ */
+export interface CandidateCheckReport {
+    readonly checks: readonly LaneCheck[];
+    readonly environment?: {
+        readonly facts: Readonly<Record<string, string | null>>;
+        readonly digest: string;
+    };
+    readonly abort?: {
+        readonly code: number;
+        readonly reason: string;
+    };
+}
+/**
+ * Normalise either arm into the report shape.
+ *
+ * 🔴 `'checks' in r`, NOT `Array.isArray(r)`. Measured with this repository's own
+ * TypeScript under `strict`: the `Array.isArray` form does not narrow a
+ * `readonly T[]` union member — its lib predicate is `arg is any[]` — and the
+ * result is a type error in both branches rather than a narrowing.
+ */
+export declare function asCheckReport(r: readonly LaneCheck[] | CandidateCheckReport): CandidateCheckReport;
+/**
+ * Every attempt that owes an evaluator verdict, newest first.
+ *
+ * 🔴 THE `unresolvedOf` OF THIS SEAM. `coverageOf` could not carry an open
+ * question, so a reader was added beside it rather than the question being
+ * forced into a shape that did not fit; the same move, for the same reason. An
+ * obligation nothing can enumerate is an obligation nobody will discharge.
+ *
+ * ⚠️ AN ATTEMPT THAT WAS NEVER PUBLISHED STILL OWES NOTHING YET. The verdict is
+ * owed on what went onto the integration branch; a refused attempt put nothing
+ * there. Callers that want both can ask for `published` themselves — this
+ * answers the question the charter asked.
+ */
+export declare function reviewsOwed(attempts: readonly IntegrationAttempt[]): IntegrationAttempt[];
+export declare function integrationLogPath(cwd: string): string;
+/**
+ * ⚠️ LED BY A NEWLINE, for the reason every ledger here is: a torn write must
+ * cost one record rather than two.
+ */
+export declare function recordAttempt(cwd: string, attempt: IntegrationAttempt): boolean;
+export declare function readAttempts(cwd: string): IntegrationAttempt[];
+export type InitResult = {
+    readonly ok: true;
+    readonly ref: string;
+    readonly sha: string;
+    readonly already: boolean;
+} | {
+    readonly ok: false;
+    readonly because: string;
+};
+/**
+ * CREATE THE INTEGRATION BASE, FROM A BASE SOMEBODY CHOSE.
+ *
+ * 🔴 NOT FROM WHATEVER HEAD HAPPENS TO BE NEARBY. Where every future run starts
+ * is a decision about the project, and inferring it from the cwd's current
+ * checkout would make it depend on which branch somebody left themselves on.
+ * The ref is named explicitly and resolved before anything is written.
+ */
+export declare function initialiseIntegration(cwd: string, from: string, git?: GitDriver): Promise<InitResult>;
+export interface IntegrationCandidate {
+    readonly branch: string;
+    readonly goalId?: string;
+    readonly runId?: string;
+    /**
+     * An evaluator verdict this candidate owes, carried in from a replay.
+     *
+     * 🔴 IT HAS TO TRAVEL, AND THE FIRST VERSION OF THIS DID NOT LET IT.
+     * The replay records ITS OWN attempt — the `needs-rebase` one — and then
+     * re-enters `integrationTick` with the carried branch. That second tick is
+     * the one that gates and PUBLISHES, and it writes a different attempt. So an
+     * obligation stamped only on the first attempt sat on a record that was never
+     * published, and `reviewsOwed` — which asks about published ones — would have
+     * enumerated exactly nothing while looking like a working feature.
+     */
+    readonly reviewOwed?: {
+        readonly reason: 'revalidate' | 'unmeasurable';
+        readonly because: string;
+    };
+    /**
+     * WHAT THIS CANDIDATE'S WORK CLAIMED TO SERVE — provenance, never a verdict.
+     *
+     * ⚠️ RESOLVED BY THE OFFERER AND CARRIED, for the same reason `goalId` is: a
+     * replay republishes under a `looply/replay-…` branch with a brand-new sha for
+     * which no ledger record exists, so a lookup inside the tick would find it for
+     * the first attempt and lose it for the one that publishes. The
+     * `{...candidate}` spread on the replay re-entry carries it, exactly as it
+     * carries `reviewOwed`.
+     */
+    readonly claim?: DeliveredClaim;
+    /**
+     * Carried in from a replay: the change touched no file the base had moved
+     * (`IntegrationDeps.replay`'s `disjoint`). Half of the owner's replay policy; the
+     * other half is that the lane publishes it. Absent is "not established".
+     */
+    readonly replayDisjoint?: boolean;
+}
+export interface IntegrationDeps {
+    readonly git: GitDriver;
+    /**
+     * The required checks, run against the CANDIDATE in its own checkout.
+     *
+     * 🔴 A CLEAN FAST-FORWARD IS NOT ACCEPTANCE. Git says the histories line up;
+     * it says nothing about whether the result builds. The run proved its own
+     * HEAD in its own workspace, and this proves the commit that would actually
+     * be published — deliberately two separate facts, because between them the
+     * base may have moved and the run's evidence is about a different tree.
+     */
+    check(at: {
+        readonly dir: string;
+        readonly sha: string;
+    }): Promise<readonly LaneCheck[] | CandidateCheckReport>;
+    now(): number;
+    newId(): string;
+    log(line: string): void;
+    /**
+     * R3 — carry a refused candidate onto the base that actually won.
+     *
+     * 🔴 THE REFUSAL IS STILL A REFUSAL. This does not soften the lane: it makes
+     * a NEW candidate from the same change, which is then offered and gated like
+     * any other. `R2-J-1` measured four workers from one base delivering one
+     * integration; without this, that is structural.
+     *
+     * ⚠️ OPTIONAL, so every existing caller and fixture is untouched, and absent
+     * behaves exactly as before: a refusal ends the work.
+     */
+    replay?(at: {
+        readonly branch: string;
+        readonly attemptId: string;
+    }): Promise<{
+        readonly kind: 'replayed';
+        readonly branch: string;
+        readonly sha: string;
+        readonly judgement: 'stands' | 'must-look-again';
+        readonly contract: 'independent' | 'revalidate' | 'unmeasurable';
+        readonly because: string;
+        readonly disjoint?: boolean;
+    } | {
+        readonly kind: 'refused';
+        readonly because: string;
+    }>;
+    /**
+     * `run.carry_into_checkouts` — what the candidate's throwaway checkout needs
+     * that git does not carry. See `checkout-carry`.
+     *
+     * ⚠️ OPTIONAL, so every existing caller and fixture is untouched, and absent
+     * behaves exactly as before: nothing is copied.
+     */
+    readonly carry?: readonly string[];
+    /**
+     * RULE #2's LANE AUTHORITY — what the goal and the acceptance map are NOW, and
+     * which environment this acceptance specification requires.
+     *
+     * ⚠️ OPTIONAL, AND ABSENT IS THE WHOLE SIMPLE-MODE GUARANTEE: no receipt is
+     * computed and no attempt field is written. Every existing caller and fixture
+     * is untouched.
+     *
+     * 🔴 IT CANNOT REFUSE A PUBLICATION, AND HAS NO BRANCH THAT COULD. It is
+     * consulted AFTER the gate is already green, and it decides only what the
+     * ledger SAYS. The lane-side gate that could refuse was reverted once already
+     * — its input defaulted to the refusing value, so in any project without a
+     * graph every carried change was refused. Neither is true here: a project with
+     * no claims gets an empty receipt, and completion is withheld by the coverage
+     * gate that exists for it, not by the lane.
+     */
+    currency?(at: {
+        readonly goalId: string;
+    }): Promise<LaneRequirementCurrency | null>;
+    /**
+     * PROGRAMME MODE'S ADMISSION RULE — see `LaneAdmission`.
+     *
+     * ⚠️ OPTIONAL, AND ABSENT IS SIMPLE MODE: every red check refuses the
+     * candidate, with the sentence it always had.
+     */
+    readonly admission?: LaneAdmission;
+}
+/** What the lane needs to judge a claim: the goal now, and the environment required. */
+export interface LaneRequirementCurrency {
+    readonly goalVersion: number;
+    readonly links: readonly RequirementLink[];
+    readonly acceptanceDigest: string;
+    readonly requiredProfile: RequiredProfile;
+}
+/**
+ * PROGRAMME MODE'S ADMISSION RULE — WHICH RED CHECKS REFUSE A CANDIDATE.
+ *
+ * 🔴 WITHOUT IT, A PROGRAMME WHOSE ACCEPTANCE IS FROZEN UP FRONT CAN INTEGRATE
+ * NOTHING UNTIL IT CAN INTEGRATE EVERYTHING. The lane runs every step of the
+ * acceptance map (`runDoctorGate`, `when:` ignored) and refused on ANY red one,
+ * so a check for a capability another goal has not written yet — red at the
+ * base and at every candidate but the last — refused every candidate before it.
+ * With goals that wait for each other's INTEGRATED work (`schedule.ts`) that is
+ * a deadlock, not a strict lane. MEASURED on LIVE-2's frozen acceptance: R2, R3
+ * and R4 all exit 1 at the base, R4 waits for integrated R2 and R3, and no
+ * candidate could ever have been published.
+ *
+ * A red check STILL REFUSES when it is:
+ *   - REQUIRED by the acceptance map, as it always has;
+ *   - one that PASSED on the lane's current base — a regression is never admitted;
+ *   - one THIS candidate's claim names as proof — work that says a check proves
+ *     it must have passed that check;
+ *   - not a step the acceptance map declares — what the lane does not know, it
+ *     does not wave through.
+ * and a base nobody could measure refuses them all: unknown is not "red before".
+ * Anything else was red on the base and is still red: NOT YET MET. It is recorded
+ * on the attempt, it does not refuse, and it is never credited.
+ *
+ * ⚠️ WHAT THIS DOES NOT CHANGE: the tip only ever gains green checks, so the last
+ * goal to land still lands only when every check the map declares is green —
+ * which is what strict completion reads. Owner decision 2026-09-24
+ * (LOOPLY-FINAL-AUTONOMOUS-01), programme mode only.
+ */
+export interface LaneAdmission {
+    /** The steps the acceptance map marks required. */
+    readonly required: ReadonlySet<string>;
+    /** Every step the acceptance map declares. */
+    readonly declared: ReadonlySet<string>;
+    /** The acceptance map a baseline must have been measured under to count. */
+    readonly acceptanceDigest: string;
+}
+export type AdmissionReason = 'required' | 'passed-on-base' | 'claimed' | 'undeclared' | 'no-baseline' | 'inconclusive' | 'did-not-run' | 'unclaimed';
+export interface AdmissionVerdict {
+    readonly refusing: readonly {
+        readonly check: LaneCheck;
+        readonly because: AdmissionReason;
+    }[];
+    readonly notYetMet: readonly string[];
+}
+/** The rule itself, on facts somebody else gathered. Pure. */
+export declare function admitCandidateChecks(checks: readonly LaneCheck[], rule: {
+    readonly admission: LaneAdmission;
+    /** Each step's result at the lane's current base, under this acceptance map; null when none could be had. */
+    readonly baseline: ReadonlyMap<string, boolean> | null;
+    /** The steps this candidate's claim names as proof. */
+    readonly claimed: ReadonlySet<string>;
+}): AdmissionVerdict;
+/** One line per base the lane has measured, keyed by revision AND acceptance map. */
+export declare function integrationBaselinePath(cwd: string): string;
+interface BaselineRecord {
+    readonly sha: string;
+    readonly acceptanceDigest: string;
+    readonly at: string;
+    readonly checks: readonly {
+        readonly name: string;
+        readonly ok: boolean;
+    }[];
+}
+/** ⚠️ LED BY A NEWLINE, like every ledger here. */
+export declare function recordBaseline(cwd: string, record: BaselineRecord): boolean;
+/**
+ * The newest baseline for this revision under THIS acceptance map, or null.
+ *
+ * ⚠️ THE DIGEST IS PART OF THE KEY. A check name is not its command: under a
+ * different map "R3 was red on the base" may be about a different check.
+ */
+export declare function readBaseline(cwd: string, sha: string, acceptanceDigest: string): Map<string, boolean> | null;
+export type TickResult = {
+    readonly kind: 'off';
+} | {
+    readonly kind: 'uninitialised';
+    readonly because: string;
+} | {
+    readonly kind: 'idle';
+    readonly because: string;
+} | {
+    readonly kind: 'refused';
+    readonly attempt: IntegrationAttempt;
+} | {
+    readonly kind: 'published';
+    readonly attempt: IntegrationAttempt;
+};
+/**
+ * ONE CANDIDATE, ONE INVOCATION, ONE AT A TIME.
+ *
+ * ⚠️ SERIALISED ON THE PROJECT'S OWN LOCK, so two daemons cannot both validate
+ * against the same base and both publish. The shared mutex is the one in
+ * `exclusive-lock`; there is no second implementation.
+ */
+export declare function integrationTick(cwd: string, candidate: IntegrationCandidate, enabled: boolean, deps: IntegrationDeps): Promise<TickResult>;
+export {};
+//# sourceMappingURL=integration-runtime.d.ts.map

package/dist/integration-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration-runtime.d.ts","sourceRoot":"","sources":["../src/integration-runtime.ts"],"names":[],"mappings":"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"}