looply-cli 0.0.0-stage → 0.2.0

package/dist/prover.d.ts

@@ -0,0 +1,80 @@
+import type { Item, ProofVerdict } from '@looply/core';
+import { type ImplementerResult } from './agent-driver';
+import type { CommandResult } from './gate';
+import type { ProofOutcome } from './round-runner';
+/**
+ * The prover invocation (DESIGN §2.2, Key 2): build the read-only prompt from
+ * exactly three things — the item title, its evidence, and the diff — and run
+ * the prover agent over it.
+ *
+ * The context deliberately carries the full implementer result even though the
+ * prompt uses none of it. The round runner holds that result, and the natural
+ * way this rule breaks is a caller "helpfully" splicing the implementer's note
+ * in for context — at which point the prover grades the story rather than the
+ * code, and the rejection rate quietly heads for the 166-for-166 zero that
+ * motivated proof in the first place (§12 case 16). Accepting the result here
+ * and provably discarding it makes the exclusion a tested boundary instead of
+ * a convention every call site must remember.
+ */
+export interface ProverContext {
+    item: Pick<Item, 'title' | 'evidence'>;
+    /** Unified diff of the round's changes, embedded in the prompt verbatim. */
+    diff: string;
+    /** Held so the exclusion is enforced (and tested) here, never used in the prompt. */
+    implementer: ImplementerResult;
+}
+/**
+ * Runs the prover agent over a finished prompt. The prompt travels as data,
+ * not as a command line: the diff is arbitrary bytes from the round's edits,
+ * and splicing it into a `shell: true` command string is an injection waiting
+ * to happen. The real backend (stdin or a temp file into the agent process)
+ * lands when the `agent:` config gap is resolved; until then every caller and
+ * test scripts this function.
+ */
+export type ProverInvoke = (prompt: string, timeoutMs: number) => Promise<CommandResult>;
+export interface ProverRunResult {
+    /** The exact prompt handed to the agent, kept for the round log (§3.2). */
+    prompt: string;
+    transcript: string;
+    ms: number;
+    /** Recorded, never decisive — the verdict parser (§12 case 15) decides. */
+    exitOk: boolean;
+    timedOut: boolean;
+}
+export declare function runProver(invoke: ProverInvoke, ctx: ProverContext, timeoutMs: number): Promise<ProverRunResult>;
+export declare function buildProverPrompt(ctx: ProverContext): string;
+/** One itemized claim from the §2.2 verdict contract. */
+export interface ProverCheck {
+    claim: string;
+    held: boolean;
+}
+/** The prover's structured verdict, DESIGN §2.2 verbatim. */
+export interface ProverVerdict {
+    verdict: ProofVerdict;
+    reason: string;
+    checks: ProverCheck[];
+    confidence: number;
+}
+export type ProverVerdictExtract = {
+    ok: true;
+    verdict: ProverVerdict;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Find the prover's verdict in a transcript: the last JSON candidate that fully
+ * validates against the §2.2 contract wins. The prompt itself embeds the contract
+ * in a fenced json block, so a transcript that echoes the prompt contains a
+ * verdict-shaped decoy — taking the *first* candidate would grade every round
+ * with the example. Scanning from the end mirrors extractImplementerResult.
+ */
+export declare function extractProverVerdict(transcript: string): ProverVerdictExtract;
+/**
+ * §12 case 15: an unparseable verdict is a rejection, not a pass. Anything short
+ * of a fully valid verdict — empty transcript, timeout, malformed JSON, a
+ * contradictory proven-with-failed-checks — maps to `rejected` with confidence 0.
+ * The exit code is recorded upstream but decides nothing here, same as case 3.
+ */
+export declare function toProofOutcome(run: ProverRunResult): ProofOutcome;
+//# sourceMappingURL=prover.d.ts.map

package/dist/prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../src/prover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,IAAI,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjE,OAAO,EAAkB,KAAK,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC,CAAC;IACvC,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,qFAAqF;IACrF,WAAW,EAAE,iBAAiB,CAAC;CAChC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAEzF,MAAM,WAAW,eAAe;IAC9B,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,2EAA2E;IAC3E,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,SAAS,CAC7B,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,aAAa,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,eAAe,CAAC,CAI1B;AAYD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,aAAa,GAAG,MAAM,CAuB5D;AAED,yDAAyD;AACzD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;CACf;AAED,6DAA6D;AAC7D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,aAAa,CAAA;CAAE,GACpC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,oBAAoB,CAU7E;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,eAAe,GAAG,YAAY,CAUjE"}

package/dist/prover.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProver = runProver;
+exports.buildProverPrompt = buildProverPrompt;
+exports.extractProverVerdict = extractProverVerdict;
+exports.toProofOutcome = toProofOutcome;
+const agent_driver_1 = require("./agent-driver");
+async function runProver(invoke, ctx, timeoutMs) {
+    const prompt = buildProverPrompt(ctx);
+    const r = await invoke(prompt, timeoutMs);
+    return { prompt, transcript: r.output ?? '', ms: r.ms, exitOk: r.ok, timedOut: r.timedOut };
+}
+/**
+ * The verdict contract quoted in the prompt is DESIGN §2.2 verbatim, so the
+ * parser on the other side (the next backlog item) validates against the same
+ * shape the agent was shown.
+ */
+const VERDICT_CONTRACT = `{ "verdict": "proven" | "rejected" | "partial",
+  "reason": "<one sentence: what held or what is missing>",
+  "checks": [{ "claim": "<a specific behaviour the item requires>", "held": true }],
+  "confidence": <0..1> }`;
+function buildProverPrompt(ctx) {
+    return [
+        'You are a prover with read-only access. You may read files; you must not modify anything.',
+        'Judge whether the diff below actually delivers what the item claims. Grade the code,',
+        'not any surrounding narrative: if a required behaviour is not visible in the diff or',
+        'the files it touches, it does not count.',
+        '',
+        `Item: ${ctx.item.title}`,
+        '',
+        renderEvidence(ctx.item.evidence),
+        '',
+        '--- BEGIN DIFF ---',
+        ctx.diff,
+        '--- END DIFF ---',
+        '',
+        'Verdicts: "proven" — the item is delivered; "rejected" — it is not, and reason says',
+        'what is missing; "partial" — some of it is delivered and the rest is not.',
+        '',
+        'Answer with exactly one JSON object in this shape and nothing after it:',
+        '```json',
+        VERDICT_CONTRACT,
+        '```',
+    ].join('\n');
+}
+/**
+ * Find the prover's verdict in a transcript: the last JSON candidate that fully
+ * validates against the §2.2 contract wins. The prompt itself embeds the contract
+ * in a fenced json block, so a transcript that echoes the prompt contains a
+ * verdict-shaped decoy — taking the *first* candidate would grade every round
+ * with the example. Scanning from the end mirrors extractImplementerResult.
+ */
+function extractProverVerdict(transcript) {
+    let why;
+    for (const candidate of (0, agent_driver_1.jsonCandidates)(transcript)) {
+        const v = validateVerdict(candidate.value);
+        if (v.ok)
+            return v;
+        // Keep the failure closest to the end — that candidate is the most likely
+        // to be the intended verdict, so its error is the one worth reporting.
+        if (why === undefined)
+            why = `the last verdict-shaped JSON is not a valid prover verdict: ${v.why}`;
+    }
+    return { ok: false, reason: why ?? 'no structured prover verdict in the transcript' };
+}
+/**
+ * §12 case 15: an unparseable verdict is a rejection, not a pass. Anything short
+ * of a fully valid verdict — empty transcript, timeout, malformed JSON, a
+ * contradictory proven-with-failed-checks — maps to `rejected` with confidence 0.
+ * The exit code is recorded upstream but decides nothing here, same as case 3.
+ */
+function toProofOutcome(run) {
+    const extracted = extractProverVerdict(run.transcript);
+    if (extracted.ok) {
+        const { verdict, reason, confidence } = extracted.verdict;
+        return { verdict, reason, confidence };
+    }
+    const reason = run.timedOut
+        ? `${extracted.reason}; the prover hit its timeout and was killed after ${run.ms}ms`
+        : extracted.reason;
+    return { verdict: 'rejected', reason, confidence: 0 };
+}
+const VERDICTS = ['proven', 'rejected', 'partial'];
+function validateVerdict(v) {
+    const verdict = v['verdict'];
+    if (typeof verdict !== 'string' || !VERDICTS.includes(verdict)) {
+        return { ok: false, why: `verdict must be one of ${VERDICTS.join(' | ')}` };
+    }
+    const reason = v['reason'];
+    if (typeof reason !== 'string' || reason.trim() === '') {
+        return { ok: false, why: 'reason must be a non-empty string' };
+    }
+    const checks = parseChecks(v['checks']);
+    if (checks === undefined) {
+        return { ok: false, why: 'checks must be a list of { claim, held } entries' };
+    }
+    const confidence = v['confidence'];
+    if (typeof confidence !== 'number' || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+        return { ok: false, why: 'confidence must be a number between 0 and 1' };
+    }
+    // Cross-check, like the implementer's blocked-iff-blocked rule: "proven" while
+    // itemizing a check that did not hold is a contradiction, and a contradictory
+    // verdict must fail closed (→ rejection via case 15) rather than commit.
+    if (verdict === 'proven' && checks.some((c) => !c.held)) {
+        return { ok: false, why: 'a proven verdict cannot list a check that did not hold' };
+    }
+    return {
+        ok: true,
+        verdict: { verdict: verdict, reason, checks, confidence },
+    };
+}
+function parseChecks(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    const out = [];
+    for (const entry of v) {
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry))
+            return undefined;
+        const o = entry;
+        const claim = o['claim'];
+        const held = o['held'];
+        if (typeof claim !== 'string' || !claim || typeof held !== 'boolean')
+            return undefined;
+        out.push({ claim, held });
+    }
+    return out;
+}
+function renderEvidence(evidence) {
+    if (evidence.length === 0)
+        return 'Evidence: none recorded for this item.';
+    const lines = evidence.map((e) => {
+        const loc = e.line === undefined ? e.path : `${e.path}:${e.line}`;
+        return e.quote === undefined ? `- ${loc}` : `- ${loc} — ${JSON.stringify(e.quote)}`;
+    });
+    return ['Evidence:', ...lines].join('\n');
+}
+//# sourceMappingURL=prover.js.map

package/dist/prover.js.map

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

package/dist/provider-identity-store.d.ts

@@ -0,0 +1,34 @@
+import { identifyProvider, type ProviderIdentity } from './provider-identity';
+import type { LedgerFs } from './ledger-store';
+/**
+ * THE PROVIDER THAT ANSWERED LAST TIME, SO A CHANGE CAN BE NOTICED.
+ *
+ * One file, rewritten each run. There is no history here on purpose: the
+ * question is "is this the same binary as last time", and a ledger of every
+ * provider a machine has ever seen would be a durable record of somebody's tool
+ * inventory for no benefit.
+ *
+ * 🔴 IT IS A DIAGNOSTIC, NOT A GATE. A provider that changed is reported and the
+ * run proceeds. Refusing would mean Looply stops working every time the user
+ * updates their coding CLI, which is a normal thing to do — and a gate that
+ * fires on a normal action is one people disable. §3.19 names the choice
+ * explicitly: diagnostic warning, compatibility re-check, or user acceptance.
+ */
+export declare class ProviderIdentityStore {
+    private readonly stateDir;
+    private readonly fs;
+    constructor(stateDir: string, fs: LedgerFs);
+    private get path();
+    /** What was recorded last, or null when nothing was — which is not a change. */
+    previous(): Promise<ProviderIdentity | null>;
+    /** Temp-then-rename, like every other durable write here. */
+    record(identity: ProviderIdentity): Promise<void>;
+}
+/**
+ * Identify the provider, compare it with last time, and record it.
+ *
+ * Returns a line to say, or null when there is nothing worth saying — which is
+ * the overwhelmingly common case and must stay silent.
+ */
+export declare function noteProviderIdentity(store: ProviderIdentityStore, input: Parameters<typeof identifyProvider>[0]): Promise<string | null>;
+//# sourceMappingURL=provider-identity-store.d.ts.map

package/dist/provider-identity-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-identity-store.d.ts","sourceRoot":"","sources":["../src/provider-identity-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAmB,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC/F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;IAE9B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,EAAE;gBADF,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,QAAQ;IAG/B,OAAO,KAAK,IAAI,GAEf;IAED,gFAAgF;IAC1E,QAAQ,IAAI,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAiBlD,6DAA6D;IACvD,MAAM,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;CAMxD;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,qBAAqB,EAC5B,KAAK,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAC5C,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAMxB"}

package/dist/provider-identity-store.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderIdentityStore = void 0;
+exports.noteProviderIdentity = noteProviderIdentity;
+const provider_identity_1 = require("./provider-identity");
+/**
+ * THE PROVIDER THAT ANSWERED LAST TIME, SO A CHANGE CAN BE NOTICED.
+ *
+ * One file, rewritten each run. There is no history here on purpose: the
+ * question is "is this the same binary as last time", and a ledger of every
+ * provider a machine has ever seen would be a durable record of somebody's tool
+ * inventory for no benefit.
+ *
+ * 🔴 IT IS A DIAGNOSTIC, NOT A GATE. A provider that changed is reported and the
+ * run proceeds. Refusing would mean Looply stops working every time the user
+ * updates their coding CLI, which is a normal thing to do — and a gate that
+ * fires on a normal action is one people disable. §3.19 names the choice
+ * explicitly: diagnostic warning, compatibility re-check, or user acceptance.
+ */
+class ProviderIdentityStore {
+    stateDir;
+    fs;
+    constructor(stateDir, fs) {
+        this.stateDir = stateDir;
+        this.fs = fs;
+    }
+    get path() {
+        return `${this.stateDir}/provider-identity.json`;
+    }
+    /** What was recorded last, or null when nothing was — which is not a change. */
+    async previous() {
+        let text;
+        try {
+            text = await this.fs.readFile(this.path);
+        }
+        catch {
+            return null;
+        }
+        if (text === null)
+            return null;
+        try {
+            const parsed = JSON.parse(text);
+            // A record from another shape is not a change, it is an unknown.
+            return typeof parsed?.schema === 'number' && typeof parsed?.kind === 'string' ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Temp-then-rename, like every other durable write here. */
+    async record(identity) {
+        await this.fs.mkdir(this.stateDir);
+        const tmp = `${this.path}.${process.pid}.tmp`;
+        await this.fs.writeFile(tmp, `${JSON.stringify(identity, null, 2)}\n`);
+        await this.fs.rename(tmp, this.path);
+    }
+}
+exports.ProviderIdentityStore = ProviderIdentityStore;
+/**
+ * Identify the provider, compare it with last time, and record it.
+ *
+ * Returns a line to say, or null when there is nothing worth saying — which is
+ * the overwhelmingly common case and must stay silent.
+ */
+async function noteProviderIdentity(store, input) {
+    const current = (0, provider_identity_1.identifyProvider)(input);
+    const previous = await store.previous().catch(() => null);
+    await store.record(current).catch(() => undefined);
+    const change = (0, provider_identity_1.providerChanged)(previous, current);
+    return change.changed ? change.because : null;
+}
+//# sourceMappingURL=provider-identity-store.js.map

package/dist/provider-identity-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-identity-store.js","sourceRoot":"","sources":["../src/provider-identity-store.ts"],"names":[],"mappings":";;;AA4DA,oDASC;AArED,2DAA+F;AAG/F;;;;;;;;;;;;;GAaG;AACH,MAAa,qBAAqB;IAEb;IACA;IAFnB,YACmB,QAAgB,EAChB,EAAY;QADZ,aAAQ,GAAR,QAAQ,CAAQ;QAChB,OAAE,GAAF,EAAE,CAAU;IAC5B,CAAC;IAEJ,IAAY,IAAI;QACd,OAAO,GAAG,IAAI,CAAC,QAAQ,yBAAyB,CAAC;IACnD,CAAC;IAED,gFAAgF;IAChF,KAAK,CAAC,QAAQ;QACZ,IAAI,IAAmB,CAAC;QACxB,IAAI,CAAC;YACH,IAAI,GAAG,MAAM,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,IAAI,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAqB,CAAC;YACpD,iEAAiE;YACjE,OAAO,OAAO,MAAM,EAAE,MAAM,KAAK,QAAQ,IAAI,OAAO,MAAM,EAAE,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;QAChG,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,6DAA6D;IAC7D,KAAK,CAAC,MAAM,CAAC,QAA0B;QACrC,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACnC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,IAAI,IAAI,OAAO,CAAC,GAAG,MAAM,CAAC;QAC9C,MAAM,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC;QACvE,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACvC,CAAC;CACF;AAnCD,sDAmCC;AAED;;;;;GAKG;AACI,KAAK,UAAU,oBAAoB,CACxC,KAA4B,EAC5B,KAA6C;IAE7C,MAAM,OAAO,GAAG,IAAA,oCAAgB,EAAC,KAAK,CAAC,CAAC;IACxC,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IAC1D,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IACnD,MAAM,MAAM,GAAG,IAAA,mCAAe,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAClD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;AAChD,CAAC"}

package/dist/provider-identity.d.ts

@@ -0,0 +1,104 @@
+import type { ProposalProvider } from '@looply/core';
+import { type AgentSpec } from './agent-exec';
+/**
+ * WHICH BINARY ANSWERED, AND WHETHER IT IS THE ONE THAT ANSWERED LAST TIME.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE ONLY TEST APPLIED TO THE PROVIDER WAS `existsSync`.
+ *
+ * A file at the derived path was executed on the strength of its NAME and
+ * LOCATION alone — no version, no size, no digest, no signature — and nothing
+ * anywhere recorded which binary a run had actually used. So if the provider
+ * changed between two runs, by update or by tampering or because a different
+ * Node install shifted the derived path, Looply would not notice and could not
+ * say so afterwards.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT THIS IS NOT
+ *
+ * ⚠️ THIS IS NOT SUPPLY-CHAIN INTEGRITY, AND SAYING SO IS THE POINT. There is no
+ * expected digest to compare against: the provider is not a dependency of
+ * Looply, appears in no lockfile, and carries no `integrity` hash anybody here
+ * could check. A digest computed from the file on disk answers "is this the same
+ * bytes as last time", never "are these the right bytes" — an attacker who can
+ * replace the binary can let it be hashed afterwards.
+ *
+ * ⚠️ AND IT IS NOT AUTHENTICODE. Nothing here verifies a signature. That would
+ * be a real improvement and it is not what this is.
+ *
+ * What it IS: a record of what ran, and a diagnostic when that changes. §3.20
+ * calls the installed provider a TRUST BOUNDARY, and the honest treatment of a
+ * trust boundary you cannot enforce is to make crossings visible.
+ */
+/** Bumped only when the recorded shape changes incompatibly. */
+export declare const PROVIDER_IDENTITY_SCHEMA = 1;
+/**
+ * How large a provider binary may be before it is described rather than read.
+ *
+ * The digest reads the file, and the packaged provider's launcher is small; a
+ * hundred megabytes would be a different kind of artefact and hashing it on
+ * every run would be a cost paid for nothing. Over the bound the identity is
+ * still recorded — size and mtime — with no digest, which is a weaker identity
+ * honestly labelled rather than a missing one.
+ */
+export declare const MAX_HASHED_PROVIDER_BYTES: number;
+export type ProviderKind = 'default' | 'configured';
+export interface ProviderIdentity {
+    readonly schema: number;
+    readonly kind: ProviderKind;
+    /**
+     * 🔴 A CATEGORY, NEVER THE PATH ITSELF.
+     *
+     * The absolute path contains the user's account name and wherever they keep
+     * their tools. This record is written to disk and read back by a diagnostic,
+     * so it says WHAT KIND of location answered rather than reproducing it.
+     */
+    readonly where: 'provider-package' | 'configured-command' | 'unknown';
+    /** Bytes, or null when the binary could not be measured. */
+    readonly bytes: number | null;
+    /** Last-modified, or null. Not an identity on its own — see the header. */
+    readonly modifiedMs: number | null;
+    /** sha256 of the executable, or null when it was too large or unreadable. */
+    readonly digest: string | null;
+}
+export interface IdentifyInput {
+    readonly kind: ProviderKind;
+    /** The resolved executable, for `default`. */
+    readonly executable?: string;
+    /** The declared command line, for `configured`. */
+    readonly command?: string;
+}
+/**
+ * Describe the provider that is about to run.
+ *
+ * 🔴 NEVER THROWS. A provider whose binary cannot be measured is still a
+ * provider that is about to run, and a diagnostic that could abort a round would
+ * be a worse thing than the gap it reports. Every unknown is a null that says so.
+ */
+export declare function identifyProvider(input: IdentifyInput): ProviderIdentity;
+export type ProviderChange = {
+    readonly changed: false;
+} | {
+    readonly changed: true;
+    readonly because: string;
+};
+/**
+ * Whether the provider differs from the one recorded last time.
+ *
+ * 🔴 A DIGEST DIFFERENCE IS THE FINDING; A SIZE OR MTIME DIFFERENCE IS A HINT.
+ * Reported in that order, and only one reason is given — a person reading a
+ * warning wants the strongest true statement, not a list.
+ *
+ * ⚠️ NO PREVIOUS RECORD IS NOT A CHANGE. The first run on a machine would
+ * otherwise announce that the provider had changed, which is both false and
+ * exactly the sort of noise that teaches people to ignore a warning.
+ */
+export declare function providerChanged(previous: ProviderIdentity | null, current: ProviderIdentity): ProviderChange;
+/**
+ * Who a record says was asked, read from the thing that will run (M3-1/M3-2):
+ * the packaged provider's identity digest when the spec names the default
+ * command, the configured command's otherwise. `packageDir` is the provider
+ * package the caller located (`claudePackageDir()`), or null when it did not.
+ */
+export declare function providerRecordFor(spec: AgentSpec, packageDir: string | null): ProposalProvider;
+//# sourceMappingURL=provider-identity.d.ts.map

package/dist/provider-identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-identity.d.ts","sourceRoot":"","sources":["../src/provider-identity.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,gEAAgE;AAChE,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,QAAmB,CAAC;AAE1D,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,YAAY,CAAC;AAEpD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,SAAS,CAAC;IACtE,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,mDAAmD;IACnD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,aAAa,GAAG,gBAAgB,CA4DvE;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,gBAAgB,GAAG,IAAI,EACjC,OAAO,EAAE,gBAAgB,GACxB,cAAc,CAuBhB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,gBAAgB,CAQ9F"}

package/dist/provider-identity.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_HASHED_PROVIDER_BYTES = exports.PROVIDER_IDENTITY_SCHEMA = void 0;
+exports.identifyProvider = identifyProvider;
+exports.providerChanged = providerChanged;
+exports.providerRecordFor = providerRecordFor;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const agent_exec_1 = require("./agent-exec");
+/**
+ * WHICH BINARY ANSWERED, AND WHETHER IT IS THE ONE THAT ANSWERED LAST TIME.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THE ONLY TEST APPLIED TO THE PROVIDER WAS `existsSync`.
+ *
+ * A file at the derived path was executed on the strength of its NAME and
+ * LOCATION alone — no version, no size, no digest, no signature — and nothing
+ * anywhere recorded which binary a run had actually used. So if the provider
+ * changed between two runs, by update or by tampering or because a different
+ * Node install shifted the derived path, Looply would not notice and could not
+ * say so afterwards.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * WHAT THIS IS NOT
+ *
+ * ⚠️ THIS IS NOT SUPPLY-CHAIN INTEGRITY, AND SAYING SO IS THE POINT. There is no
+ * expected digest to compare against: the provider is not a dependency of
+ * Looply, appears in no lockfile, and carries no `integrity` hash anybody here
+ * could check. A digest computed from the file on disk answers "is this the same
+ * bytes as last time", never "are these the right bytes" — an attacker who can
+ * replace the binary can let it be hashed afterwards.
+ *
+ * ⚠️ AND IT IS NOT AUTHENTICODE. Nothing here verifies a signature. That would
+ * be a real improvement and it is not what this is.
+ *
+ * What it IS: a record of what ran, and a diagnostic when that changes. §3.20
+ * calls the installed provider a TRUST BOUNDARY, and the honest treatment of a
+ * trust boundary you cannot enforce is to make crossings visible.
+ */
+/** Bumped only when the recorded shape changes incompatibly. */
+exports.PROVIDER_IDENTITY_SCHEMA = 1;
+/**
+ * How large a provider binary may be before it is described rather than read.
+ *
+ * The digest reads the file, and the packaged provider's launcher is small; a
+ * hundred megabytes would be a different kind of artefact and hashing it on
+ * every run would be a cost paid for nothing. Over the bound the identity is
+ * still recorded — size and mtime — with no digest, which is a weaker identity
+ * honestly labelled rather than a missing one.
+ */
+exports.MAX_HASHED_PROVIDER_BYTES = 64 * 1024 * 1024;
+/**
+ * Describe the provider that is about to run.
+ *
+ * 🔴 NEVER THROWS. A provider whose binary cannot be measured is still a
+ * provider that is about to run, and a diagnostic that could abort a round would
+ * be a worse thing than the gap it reports. Every unknown is a null that says so.
+ */
+function identifyProvider(input) {
+    if (input.kind === 'configured') {
+        /**
+         * A configured provider is a SHELL LINE a person wrote, not a binary Looply
+         * resolved — the executable is `cmd.exe` and the real program is somewhere
+         * inside the line. So the identity is of the LINE. That is genuinely weaker,
+         * and calling it `configured-command` says which kind of answer this is.
+         */
+        const command = input.command ?? '';
+        return {
+            schema: exports.PROVIDER_IDENTITY_SCHEMA,
+            kind: 'configured',
+            where: 'configured-command',
+            bytes: null,
+            modifiedMs: null,
+            digest: command === ''
+                ? null
+                : (0, node_crypto_1.createHash)('sha256').update(`looply-provider-command-v1\n${command}`, 'utf8').digest('hex'),
+        };
+    }
+    const executable = input.executable ?? '';
+    const unknown = {
+        schema: exports.PROVIDER_IDENTITY_SCHEMA,
+        kind: 'default',
+        where: executable === '' ? 'unknown' : 'provider-package',
+        bytes: null,
+        modifiedMs: null,
+        digest: null,
+    };
+    if (executable === '')
+        return unknown;
+    let bytes;
+    let modifiedMs;
+    try {
+        const s = (0, node_fs_1.statSync)(executable);
+        bytes = s.size;
+        modifiedMs = Math.floor(s.mtimeMs);
+    }
+    catch {
+        return unknown;
+    }
+    let digest = null;
+    if (bytes <= exports.MAX_HASHED_PROVIDER_BYTES) {
+        try {
+            digest = (0, node_crypto_1.createHash)('sha256').update((0, node_fs_1.readFileSync)(executable)).digest('hex');
+        }
+        catch {
+            // Unreadable is recorded as a missing digest, not as a missing identity.
+            digest = null;
+        }
+    }
+    return {
+        schema: exports.PROVIDER_IDENTITY_SCHEMA,
+        kind: 'default',
+        where: 'provider-package',
+        bytes,
+        modifiedMs,
+        digest,
+    };
+}
+/**
+ * Whether the provider differs from the one recorded last time.
+ *
+ * 🔴 A DIGEST DIFFERENCE IS THE FINDING; A SIZE OR MTIME DIFFERENCE IS A HINT.
+ * Reported in that order, and only one reason is given — a person reading a
+ * warning wants the strongest true statement, not a list.
+ *
+ * ⚠️ NO PREVIOUS RECORD IS NOT A CHANGE. The first run on a machine would
+ * otherwise announce that the provider had changed, which is both false and
+ * exactly the sort of noise that teaches people to ignore a warning.
+ */
+function providerChanged(previous, current) {
+    if (previous === null)
+        return { changed: false };
+    if (previous.kind !== current.kind) {
+        return { changed: true, because: `the provider kind changed from ${previous.kind} to ${current.kind}` };
+    }
+    if (previous.digest !== null && current.digest !== null && previous.digest !== current.digest) {
+        return { changed: true, because: 'the provider executable has different contents than the last run' };
+    }
+    if (previous.bytes !== null && current.bytes !== null && previous.bytes !== current.bytes) {
+        return { changed: true, because: `the provider executable changed size (${previous.bytes} → ${current.bytes} bytes)` };
+    }
+    if (previous.digest !== null &&
+        current.digest === null &&
+        previous.modifiedMs !== null &&
+        current.modifiedMs !== null &&
+        previous.modifiedMs !== current.modifiedMs) {
+        // Only when there is no digest to ask instead: mtime moves for reasons that
+        // are not changes, and reporting it over a matching digest would be noise.
+        return { changed: true, because: 'the provider executable was modified since the last run' };
+    }
+    return { changed: false };
+}
+/**
+ * Who a record says was asked, read from the thing that will run (M3-1/M3-2):
+ * the packaged provider's identity digest when the spec names the default
+ * command, the configured command's otherwise. `packageDir` is the provider
+ * package the caller located (`claudePackageDir()`), or null when it did not.
+ */
+function providerRecordFor(spec, packageDir) {
+    const isDefault = spec.command === agent_exec_1.DEFAULT_AGENT.command;
+    const identity = identifyProvider(isDefault
+        ? { kind: 'default', ...(packageDir === null ? {} : { executable: (0, node_path_1.join)(packageDir, 'bin', 'claude.exe') }) }
+        : { kind: 'configured', command: spec.command });
+    return { kind: identity.kind, role: 'brain', command: spec.command, digest: identity.digest };
+}
+//# sourceMappingURL=provider-identity.js.map

package/dist/provider-identity.js.map

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