looply-cli 0.0.0-stage → 0.2.0

package/dist/verifier.d.ts

@@ -0,0 +1,66 @@
+import type { EventData, Item } from '@looply/core';
+import type { CommandResult } from './gate';
+/**
+ * The verifier invocation (DESIGN §10, §12 cases 17–18): every item, from any
+ * source, is checked by a read-only agent before it can be picked. The verifier
+ * judges the item's *premise* against the code as it stands now — an item whose
+ * defect is already fixed is `stale` (case 17), an item another lens already
+ * filed is `duplicate` (case 18) — so the loop never spends a round implementing
+ * something that does not need implementing.
+ */
+export interface VerifierContext {
+    item: Pick<Item, 'id' | 'title' | 'tag' | 'evidence'>;
+    /**
+     * The other open items in the queue, so the verifier can name which one this
+     * duplicates (§12 case 18). Titles plus ids: `duplicateOf` must be an id the
+     * queue can actually merge into, and the agent can only name what it was shown.
+     */
+    others: ReadonlyArray<{
+        id: string;
+        title: string;
+    }>;
+}
+/** Same invoke seam as the prover: the prompt travels as data, never a command line. */
+export type VerifierInvoke = (prompt: string, timeoutMs: number) => Promise<CommandResult>;
+export interface VerifierRunResult {
+    /** The exact prompt handed to the agent, kept for the log (§3.2). */
+    prompt: string;
+    transcript: string;
+    ms: number;
+    /** Recorded, never decisive — the verdict parser decides, same as §12 cases 3/15. */
+    exitOk: boolean;
+    timedOut: boolean;
+}
+export declare function runVerifier(invoke: VerifierInvoke, ctx: VerifierContext, timeoutMs: number): Promise<VerifierRunResult>;
+export declare function buildVerifierPrompt(ctx: VerifierContext): string;
+/**
+ * The verifier's structured verdict. `note` carries the agent's `reason` — named
+ * to match the `item.verified` payload, so a caller emits the event as
+ * `{ itemId, ...outcome }` with nothing renamed along the way.
+ */
+export type VerifyOutcome = Omit<EventData['item.verified'], 'itemId'> & {
+    note: string;
+};
+export type VerifierVerdictExtract = {
+    ok: true;
+    verdict: VerifyOutcome;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Find the verifier's verdict in a transcript: the last JSON candidate that
+ * fully validates wins. The prompt embeds the contract in a fenced json block,
+ * so a transcript that echoes the prompt contains a verdict-shaped decoy —
+ * scanning from the end mirrors extractProverVerdict.
+ */
+export declare function extractVerifierVerdict(transcript: string): VerifierVerdictExtract;
+/**
+ * The backlog rule this module exists for: an unparseable verdict is never
+ * `confirmed`. It maps to `unclear` — back to draft and into a question, never
+ * pickable — because the alternative reading (treat garbage as confirmation and
+ * move on) is exactly how a queue fills with unverified work while looking
+ * verified, the queue-side twin of §12 case 15's unparseable-proof-is-a-pass.
+ */
+export declare function toVerifyOutcome(run: VerifierRunResult): VerifyOutcome;
+//# sourceMappingURL=verifier.d.ts.map

package/dist/verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifier.d.ts","sourceRoot":"","sources":["../src/verifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAY,SAAS,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAE5C;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,GAAG,KAAK,GAAG,UAAU,CAAC,CAAC;IACtD;;;;OAIG;IACH,MAAM,EAAE,aAAa,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACtD;AAED,wFAAwF;AACxF,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;AAE3F,MAAM,WAAW,iBAAiB;IAChC,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,qFAAqF;IACrF,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,wBAAsB,WAAW,CAC/B,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,iBAAiB,CAAC,CAI5B;AAcD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAyBhE;AAED;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,EAAE,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F,MAAM,MAAM,sBAAsB,GAC9B;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;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,sBAAsB,CAQjF;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,iBAAiB,GAAG,aAAa,CAOrE"}

package/dist/verifier.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runVerifier = runVerifier;
+exports.buildVerifierPrompt = buildVerifierPrompt;
+exports.extractVerifierVerdict = extractVerifierVerdict;
+exports.toVerifyOutcome = toVerifyOutcome;
+const agent_driver_1 = require("./agent-driver");
+async function runVerifier(invoke, ctx, timeoutMs) {
+    const prompt = buildVerifierPrompt(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, so the parser validates against
+ * the same shape the agent was shown. Fields deliberately mirror the
+ * `item.verified` ledger payload: what the verifier answers is what the ledger
+ * records, with no translation layer to drift.
+ */
+const VERDICT_CONTRACT = `{ "verdict": "confirmed" | "amended" | "stale" | "duplicate" | "blocked" | "too-big" | "unclear",
+  "reason": "<one sentence: why this verdict>",
+  "evidence": [{ "path": "<file>", "line": 123, "quote": "<the line that proves the premise>" }],
+  "amendedTitle": "<amended only: the corrected title>",
+  "duplicateOf": "<duplicate only: the id of the open item this duplicates>" }`;
+function buildVerifierPrompt(ctx) {
+    return [
+        'You are a verifier with read-only access. You may read files; you must not modify anything.',
+        'Judge whether the item below is worth implementing against the code as it stands NOW.',
+        'Check the premise, not the plan: if the defect it describes is already fixed, the item',
+        'is stale no matter how well written it is.',
+        '',
+        `Item ${ctx.item.id} [${ctx.item.tag}]: ${ctx.item.title}`,
+        '',
+        renderEvidence(ctx.item.evidence),
+        '',
+        renderOthers(ctx.others),
+        '',
+        'Verdicts: "confirmed" — the premise holds; cite the file:line that proves it in evidence.',
+        '"amended" — the defect is real but the title is wrong or imprecise; supply amendedTitle',
+        'and the evidence for the corrected premise. "stale" — the premise is already fixed.',
+        '"duplicate" — an open item above describes the same defect; name it in duplicateOf.',
+        '"blocked" — it cannot proceed and reason says why. "too-big" — it is several rounds of',
+        'work and must be split. "unclear" — you cannot tell what it is asking for.',
+        '',
+        'Answer with exactly one JSON object in this shape and nothing after it:',
+        '```json',
+        VERDICT_CONTRACT,
+        '```',
+    ].join('\n');
+}
+/**
+ * Find the verifier's verdict in a transcript: the last JSON candidate that
+ * fully validates wins. The prompt embeds the contract in a fenced json block,
+ * so a transcript that echoes the prompt contains a verdict-shaped decoy —
+ * scanning from the end mirrors extractProverVerdict.
+ */
+function extractVerifierVerdict(transcript) {
+    let why;
+    for (const candidate of (0, agent_driver_1.jsonCandidates)(transcript)) {
+        const v = validateVerdict(candidate.value);
+        if (v.ok)
+            return v;
+        if (why === undefined)
+            why = `the last verdict-shaped JSON is not a valid verifier verdict: ${v.why}`;
+    }
+    return { ok: false, reason: why ?? 'no structured verifier verdict in the transcript' };
+}
+/**
+ * The backlog rule this module exists for: an unparseable verdict is never
+ * `confirmed`. It maps to `unclear` — back to draft and into a question, never
+ * pickable — because the alternative reading (treat garbage as confirmation and
+ * move on) is exactly how a queue fills with unverified work while looking
+ * verified, the queue-side twin of §12 case 15's unparseable-proof-is-a-pass.
+ */
+function toVerifyOutcome(run) {
+    const extracted = extractVerifierVerdict(run.transcript);
+    if (extracted.ok)
+        return extracted.verdict;
+    const note = run.timedOut
+        ? `${extracted.reason}; the verifier hit its timeout and was killed after ${run.ms}ms`
+        : extracted.reason;
+    return { verdict: 'unclear', note };
+}
+const VERDICTS = ['confirmed', 'amended', 'stale', 'duplicate', 'blocked', 'too-big', 'unclear'];
+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 word = verdict;
+    const reason = v['reason'];
+    if (typeof reason !== 'string' || reason.trim() === '') {
+        return { ok: false, why: 'reason must be a non-empty string' };
+    }
+    const evidence = parseEvidence(v['evidence']);
+    if (evidence === undefined) {
+        return { ok: false, why: 'evidence must be a list of { path, line?, quote? } entries' };
+    }
+    // §10: "confirmed caches evidence" — confirmation IS the moment the evidence
+    // cache is filled, and amended makes an item ready exactly like confirmed
+    // does. A pickable verdict with nothing to cache would send the implementer
+    // searching for the defect again, the failure the cache exists to prevent,
+    // so it fails closed here instead of passing as a hollow confirmation.
+    if ((word === 'confirmed' || word === 'amended') && evidence.length === 0) {
+        return { ok: false, why: `a ${word} verdict must cite at least one evidence entry` };
+    }
+    const amendedTitle = v['amendedTitle'];
+    if (word === 'amended' && (typeof amendedTitle !== 'string' || amendedTitle.trim() === '')) {
+        return { ok: false, why: 'an amended verdict must supply the corrected title' };
+    }
+    const duplicateOf = v['duplicateOf'];
+    if (word === 'duplicate' && (typeof duplicateOf !== 'string' || duplicateOf.trim() === '')) {
+        return { ok: false, why: 'a duplicate verdict must name the item it duplicates' };
+    }
+    // Only the fields the verdict word licenses are carried out: an off-verdict
+    // amendedTitle/duplicateOf never leaks into the item.verified payload.
+    const out = { verdict: word, note: reason };
+    if (evidence.length > 0)
+        out.evidence = evidence;
+    if (word === 'amended')
+        out.amendedTitle = amendedTitle;
+    if (word === 'duplicate')
+        out.duplicateOf = duplicateOf;
+    return { ok: true, verdict: out };
+}
+function parseEvidence(v) {
+    if (v === undefined)
+        return [];
+    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 path = o['path'];
+        if (typeof path !== 'string' || path === '')
+            return undefined;
+        const e = { path };
+        const line = o['line'];
+        if (line !== undefined) {
+            if (typeof line !== 'number' || !Number.isFinite(line))
+                return undefined;
+            e.line = line;
+        }
+        const quote = o['quote'];
+        if (quote !== undefined) {
+            if (typeof quote !== 'string')
+                return undefined;
+            e.quote = quote;
+        }
+        out.push(e);
+    }
+    return out;
+}
+function renderEvidence(evidence) {
+    if (evidence.length === 0)
+        return 'Evidence on file: none — find the premise in the code yourself.';
+    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 on file:', ...lines].join('\n');
+}
+function renderOthers(others) {
+    if (others.length === 0)
+        return 'Other open items: none.';
+    const lines = others.map((o) => `- ${o.id} — ${o.title}`);
+    return ['Other open items (for the duplicate check):', ...lines].join('\n');
+}
+//# sourceMappingURL=verifier.js.map

package/dist/verifier.js.map

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

package/dist/verify-apply.d.ts

@@ -0,0 +1,26 @@
+import { type Evidence, type Item, type ItemState } from '@looply/core';
+import type { ItemPatch } from './queue-store';
+import type { VerifyOutcome } from './verifier';
+/**
+ * Turning a verifier verdict into a queue change.
+ *
+ * Extracted from the round runner because there are two callers, and they must
+ * agree exactly. The runner re-verifies an item at pick time when its cached
+ * evidence has gone stale (DESIGN section 12 case 19); the verification pass
+ * walks the drafts a scan produced. If those two applied verdicts differently,
+ * whether an item became pickable would depend on which route happened to
+ * reach it — so the decision lives here, once, as a pure function.
+ */
+export interface AppliedVerdict {
+    /** The verdict actually applied, which may have been degraded from the input. */
+    outcome: VerifyOutcome;
+    next: ItemState;
+    patch: ItemPatch;
+    /** Evidence worth caching at the verified HEAD, or null when there is none. */
+    cacheEvidence: readonly Evidence[] | null;
+}
+/**
+ * @param lookup resolves an item id against the queue, for checking `duplicateOf`.
+ */
+export declare function applyVerifyVerdict(item: Pick<Item, 'id'>, outcome: VerifyOutcome, lookup: (id: string) => Item | undefined): AppliedVerdict;
+//# sourceMappingURL=verify-apply.d.ts.map

package/dist/verify-apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-apply.d.ts","sourceRoot":"","sources":["../src/verify-apply.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;GASG;AAEH,MAAM,WAAW,cAAc;IAC7B,iFAAiF;IACjF,OAAO,EAAE,aAAa,CAAC;IACvB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;IACjB,+EAA+E;IAC/E,aAAa,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI,CAAC;CAC3C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,EACtB,OAAO,EAAE,aAAa,EACtB,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,GAAG,SAAS,GACvC,cAAc,CAyBhB"}

package/dist/verify-apply.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyVerifyVerdict = applyVerifyVerdict;
+const core_1 = require("@looply/core");
+/**
+ * @param lookup resolves an item id against the queue, for checking `duplicateOf`.
+ */
+function applyVerifyVerdict(item, outcome, lookup) {
+    // The verdict parser is context-free, so `duplicateOf` may name a bogus or
+    // *self* id — applied as-is, a self-duplicate would close the item against
+    // itself and lose it. An unusable duplicate verdict degrades to `unclear`:
+    // back to draft where a human decides, never silently dropped.
+    let applied = outcome;
+    if (outcome.verdict === 'duplicate') {
+        const target = outcome.duplicateOf === undefined ? undefined : lookup(outcome.duplicateOf);
+        if (target === undefined || target.id === item.id) {
+            applied = {
+                verdict: 'unclear',
+                note: `duplicate verdict names ${outcome.duplicateOf ?? '(nothing)'}, which is not another item in the queue`,
+            };
+        }
+    }
+    const next = (0, core_1.afterVerify)(applied.verdict);
+    const patch = { state: next };
+    if (next === 'ready' && applied.evidence !== undefined)
+        patch.evidence = applied.evidence;
+    if (applied.verdict === 'amended' && applied.amendedTitle !== undefined)
+        patch.title = applied.amendedTitle;
+    if (applied.verdict === 'duplicate' && applied.duplicateOf !== undefined)
+        patch.duplicateOf = applied.duplicateOf;
+    if (applied.verdict === 'blocked')
+        patch.blockedReason = applied.note;
+    const hasEvidence = next === 'ready' && applied.evidence !== undefined && applied.evidence.length > 0;
+    return { outcome: applied, next, patch, cacheEvidence: hasEvidence ? applied.evidence ?? null : null };
+}
+//# sourceMappingURL=verify-apply.js.map

package/dist/verify-apply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-apply.js","sourceRoot":"","sources":["../src/verify-apply.ts"],"names":[],"mappings":";;AA2BA,gDA6BC;AAxDD,uCAAqF;AAwBrF;;GAEG;AACH,SAAgB,kBAAkB,CAChC,IAAsB,EACtB,OAAsB,EACtB,MAAwC;IAExC,2EAA2E;IAC3E,2EAA2E;IAC3E,2EAA2E;IAC3E,+DAA+D;IAC/D,IAAI,OAAO,GAAG,OAAO,CAAC;IACtB,IAAI,OAAO,CAAC,OAAO,KAAK,WAAW,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,OAAO,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC3F,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,EAAE,CAAC;YAClD,OAAO,GAAG;gBACR,OAAO,EAAE,SAAS;gBAClB,IAAI,EAAE,2BAA2B,OAAO,CAAC,WAAW,IAAI,WAAW,0CAA0C;aAC9G,CAAC;QACJ,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAAG,IAAA,kBAAW,EAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1C,MAAM,KAAK,GAAc,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACzC,IAAI,IAAI,KAAK,OAAO,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS;QAAE,KAAK,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAC1F,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,YAAY,KAAK,SAAS;QAAE,KAAK,CAAC,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC;IAC5G,IAAI,OAAO,CAAC,OAAO,KAAK,WAAW,IAAI,OAAO,CAAC,WAAW,KAAK,SAAS;QAAE,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAClH,IAAI,OAAO,CAAC,OAAO,KAAK,SAAS;QAAE,KAAK,CAAC,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAEtE,MAAM,WAAW,GAAG,IAAI,KAAK,OAAO,IAAI,OAAO,CAAC,QAAQ,KAAK,SAAS,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IACtG,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AACzG,CAAC"}

package/dist/verify-cmd.d.ts

@@ -0,0 +1,44 @@
+import type { Item } from '@looply/core';
+import { type AgentInvoke } from './agent-exec';
+import type { LooplyConfig } from './config';
+import { type VerifyOutcome } from './verifier';
+import { type VerifyPassQueue, type VerifyPassReport } from './verify-pass';
+/**
+ * The composition root for `looply verify`, and the shared verifier the run
+ * uses at pick time. Both routes build the item verifier the same way, so what
+ * the verifier is shown does not depend on who asked.
+ */
+export declare const VERIFIER_TIMEOUT_MS: number;
+/**
+ * How many drafts one run checks before it starts working.
+ *
+ * The pass is sequential and each draft costs up to VERIFIER_TIMEOUT_MS, and
+ * ALL of it happens before `run.started` — which is the only thing that acks
+ * the start-run that asked for the run. That command expires one hour after it
+ * was issued, so an uncapped pass over enough drafts silently spends the whole
+ * window and the command is marked expired while the run carries on unacked.
+ *
+ * `draftsToVerify` has taken a `max` since it was written; nothing passed one.
+ * The full sum, and the compiler bound derived from it, are asserted in
+ * `goal-compile.spec.ts` against these real constants.
+ *
+ * Drafts past the cap are not lost — they stay `draft`, and the next run checks
+ * them. This bounds one pass, not the queue.
+ */
+export declare const VERIFY_MAX_PER_RUN = 6;
+/**
+ * One item verifier.
+ *
+ * The rest of the open queue travels with the item so a duplicate can be named
+ * by id rather than merely suspected — the verifier can only point at what it
+ * was shown.
+ */
+export declare function makeItemVerifier(agent: AgentInvoke, queue: Pick<VerifyPassQueue, 'list'>): (item: Item) => Promise<VerifyOutcome>;
+export interface VerifyOptions {
+    cwd: string;
+    config: LooplyConfig;
+    max?: number;
+    log: (line: string) => void;
+}
+export declare function verifyCommand(opts: VerifyOptions): Promise<VerifyPassReport>;
+//# sourceMappingURL=verify-cmd.d.ts.map

package/dist/verify-cmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-cmd.d.ts","sourceRoot":"","sources":["../src/verify-cmd.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAO7C,OAAO,EAAgC,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAC9E,OAAO,EAAgB,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAG1F;;;;GAIG;AAEH,eAAO,MAAM,mBAAmB,QAAgB,CAAC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,GACnC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,aAAa,CAAC,CAaxC;AAED,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,YAAY,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwBlF"}

package/dist/verify-cmd.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERIFY_MAX_PER_RUN = exports.VERIFIER_TIMEOUT_MS = void 0;
+exports.makeItemVerifier = makeItemVerifier;
+exports.verifyCommand = verifyCommand;
+const node_path_1 = require("node:path");
+const model_transport_1 = require("./model-transport");
+const providers_1 = require("./providers");
+const evidence_cache_1 = require("./evidence-cache");
+const git_driver_1 = require("./git-driver");
+const ledger_store_1 = require("./ledger-store");
+const queue_store_1 = require("./queue-store");
+const sync_1 = require("./sync");
+const syncing_ledger_1 = require("./syncing-ledger");
+const verifier_1 = require("./verifier");
+const verify_pass_1 = require("./verify-pass");
+const queue_write_lease_1 = require("./queue-write-lease");
+/**
+ * The composition root for `looply verify`, and the shared verifier the run
+ * uses at pick time. Both routes build the item verifier the same way, so what
+ * the verifier is shown does not depend on who asked.
+ */
+exports.VERIFIER_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * How many drafts one run checks before it starts working.
+ *
+ * The pass is sequential and each draft costs up to VERIFIER_TIMEOUT_MS, and
+ * ALL of it happens before `run.started` — which is the only thing that acks
+ * the start-run that asked for the run. That command expires one hour after it
+ * was issued, so an uncapped pass over enough drafts silently spends the whole
+ * window and the command is marked expired while the run carries on unacked.
+ *
+ * `draftsToVerify` has taken a `max` since it was written; nothing passed one.
+ * The full sum, and the compiler bound derived from it, are asserted in
+ * `goal-compile.spec.ts` against these real constants.
+ *
+ * Drafts past the cap are not lost — they stay `draft`, and the next run checks
+ * them. This bounds one pass, not the queue.
+ */
+exports.VERIFY_MAX_PER_RUN = 6;
+/**
+ * One item verifier.
+ *
+ * The rest of the open queue travels with the item so a duplicate can be named
+ * by id rather than merely suspected — the verifier can only point at what it
+ * was shown.
+ */
+function makeItemVerifier(agent, queue) {
+    return async (item) => {
+        const others = queue
+            .list()
+            .filter((i) => i.id !== item.id && (i.state === 'ready' || i.state === 'draft'))
+            .map((i) => ({ id: i.id, title: i.title }));
+        const run = await (0, verifier_1.runVerifier)(agent, { item: { id: item.id, title: item.title, tag: item.tag, evidence: item.evidence }, others }, exports.VERIFIER_TIMEOUT_MS);
+        return (0, verifier_1.toVerifyOutcome)(run);
+    };
+}
+async function verifyCommand(opts) {
+    /**
+     * 🔴 THE LEASE, BECAUSE THIS WRITES `queue.json` AND A RUN HOLDS IT WHOLESALE.
+     *
+     * `verifyDrafts` patches every item it judges, and `QueueStore.persist` writes
+     * the entire in-memory map. A run that opened the queue hours ago writes its
+     * own snapshot back after its next round, so a verify pass that landed during
+     * a run had its verdicts silently reverted — every item back to `draft`, no
+     * error, and a report saying it had confirmed them.
+     *
+     * ⚠️ AT THE TOP, UNLIKE `scan`, because there is no read-only mode here: this
+     * command's entire purpose is to write verdicts. There is nothing it could
+     * usefully do while refusing to write.
+     *
+     * ⚠️ AND IT IS SAFE TO ACQUIRE UNCONDITIONALLY. A run does not call this — it
+     * builds its own verifier through `makeItemVerifier` — so there is no path on
+     * which this waits for a lease its own caller is holding.
+     */
+    const held = await (0, queue_write_lease_1.takeQueueWriteLease)(opts.cwd, 'a verify pass');
+    try {
+        return await runVerify(opts);
+    }
+    finally {
+        await held.release();
+    }
+}
+async function runVerify(opts) {
+    const { cwd, config, log } = opts;
+    const stateDir = (0, node_path_1.join)(cwd, git_driver_1.STATE_DIR, 'state');
+    const ledger = new ledger_store_1.LedgerStore(stateDir, ledger_store_1.nodeLedgerFs);
+    const queue = new queue_store_1.QueueStore(stateDir, ledger_store_1.nodeLedgerFs);
+    const evidence = new evidence_cache_1.EvidenceCache(stateDir, ledger_store_1.nodeLedgerFs);
+    const git = new git_driver_1.GitDriver((0, git_driver_1.nodeGitExec)(cwd));
+    await ledger.open();
+    await queue.open();
+    await evidence.open();
+    const sync = await (0, sync_1.attachSync)(cwd, config, log);
+    const ledgerForPass = sync ? new syncing_ledger_1.SyncingLedger(ledger, sync.daemon, (0, syncing_ledger_1.logSinkErrorOnce)(log)) : ledger;
+    // LEAST PRIVILEGE. Verifying is forming a judgement about code that already
+    // exists, so this role reads and searches and cannot write. Handing it edit
+    // and write because the implementer has them would be granting authority
+    // nothing asked for.
+    /**
+     * 🔴 THE PRESET, HERE TOO. See `agentSpecFor`: this passed `config.agent`
+     * unresolved, so `looply verify` ignored `agent.provider` and started a
+     * different binary from the one `looply run` starts in the same project.
+     */
+    const picked = (0, providers_1.agentSpecFor)(config);
+    if (!picked.ok)
+        throw new Error(picked.message);
+    const agent = (0, model_transport_1.makeMediatedAgentRunner)(cwd, 'verifier', picked.spec);
+    const report = await (0, verify_pass_1.verifyDrafts)({
+        queue,
+        ledger: ledgerForPass,
+        verify: makeItemVerifier(agent, queue),
+        cachePut: (id, head, ev) => evidence.put(id, head, ev),
+        headSha: () => git.headSha(),
+        projectId: sync?.projectId ?? config.project.id ?? 'local',
+        now: () => Date.now(),
+        onVerdict: (item, outcome) => {
+            const mark = outcome.verdict === 'confirmed' || outcome.verdict === 'amended' ? 'ready' : outcome.verdict;
+            log(`verify  : ${mark.padEnd(9)} ${item.title.slice(0, 68)}`);
+        },
+    }, opts.max === undefined ? {} : { max: opts.max });
+    await sync?.stop();
+    return report;
+}
+//# sourceMappingURL=verify-cmd.js.map

package/dist/verify-cmd.js.map

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

package/dist/verify-pass.d.ts

@@ -0,0 +1,73 @@
+import { type Evidence, type Item } from '@looply/core';
+import type { AnyEventInput } from './ledger-store';
+import type { ItemPatch, QueueWriteResult } from './queue-store';
+import type { VerifyOutcome } from './verifier';
+/**
+ * The verification pass: draft items become pickable, or they do not.
+ *
+ * This closes the gap between the two commands the product is built around.
+ * `scan` writes items in `draft`, because a finding an agent volunteered is a
+ * claim and not yet a task. `run` picks only `ready`. Nothing joined the two,
+ * so a freshly scanned project could not be run at all: `run` refused with "no
+ * ready items" and told the user to mark one from the phone — advice that is
+ * useless on an unpaired machine and wrong even on a paired one, since marking
+ * an item ready by hand is exactly the unchecked premise verification exists to
+ * prevent.
+ *
+ * The pass is deliberately its own command as well as an automatic step. It is
+ * the cheapest agent work looply does and the easiest to reason about, so being
+ * able to run it alone — see what survives contact with the code before
+ * spending a round on anything — is worth more than the tidiness of hiding it.
+ *
+ * A pass is not a run: no round happens and nothing is committed. It mints a
+ * run-shaped id and marks the lane, exactly as a scan does, so the ledger and
+ * the app can tell the three apart without a schema change.
+ */
+export declare const VERIFY_LANE = "verify";
+export interface VerifyPassQueue {
+    list(): Item[];
+    get(id: string): Item | undefined;
+    update(id: string, expectedVersion: number, patch: ItemPatch): Promise<QueueWriteResult>;
+}
+export interface VerifyPassDeps {
+    queue: VerifyPassQueue;
+    ledger: {
+        append(input: AnyEventInput): Promise<unknown>;
+    };
+    /** Runs the verifier for one item; prompt construction lives with the caller. */
+    verify(item: Item): Promise<VerifyOutcome>;
+    /** Refills the evidence cache so the next pick is a hit rather than a re-verify. */
+    cachePut(itemId: string, head: string, evidence: readonly Evidence[]): Promise<void>;
+    headSha(): Promise<string>;
+    projectId: string;
+    now(): number;
+    /** Progress, one call per item as its verdict lands. */
+    onVerdict?(item: Item, outcome: VerifyOutcome): void;
+}
+export interface VerifyPassOptions {
+    /** Cap the number of items checked; the rest stay draft. */
+    max?: number;
+    /** Check only these ids. Default: every draft, in queue order. */
+    only?: readonly string[];
+}
+export interface VerifyPassReport {
+    checked: number;
+    /** How many are now pickable — the only number that decides whether a run can start. */
+    ready: number;
+    byVerdict: Record<string, number>;
+    /** Items that could not be read back after the update; a bug, not a verdict. */
+    failed: number;
+}
+/**
+ * What a pass would check, in queue order.
+ *
+ * Includes items stuck in `verifying`. That state is held only for the length
+ * of one verifier call, so an item still in it when a pass begins is one whose
+ * process died mid-call — killed run, closed laptop, crash. Left out, it is
+ * stranded permanently: pickable by nothing, and never looked at again. The
+ * version check on the write makes reclaiming it safe if something really is
+ * still working on it — that write loses and is reported, rather than racing.
+ */
+export declare function draftsToVerify(items: readonly Item[], opts?: VerifyPassOptions): Item[];
+export declare function verifyDrafts(deps: VerifyPassDeps, opts?: VerifyPassOptions): Promise<VerifyPassReport>;
+//# sourceMappingURL=verify-pass.d.ts.map

package/dist/verify-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-pass.d.ts","sourceRoot":"","sources":["../src/verify-pass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,QAAQ,EAAE,KAAK,IAAI,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,eAAO,MAAM,WAAW,WAAW,CAAC;AAKpC,MAAM,WAAW,eAAe;IAC9B,IAAI,IAAI,IAAI,EAAE,CAAC;IACf,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAClC,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC1F;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE;QAAE,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;IAC3D,iFAAiF;IACjF,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAC3C,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrF,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,IAAI,MAAM,CAAC;IACd,wDAAwD;IACxD,SAAS,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;CACtD;AAED,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,wFAAwF;IACxF,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,gFAAgF;IAChF,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,IAAI,GAAE,iBAAsB,GAAG,IAAI,EAAE,CAM3F;AAED,wBAAsB,YAAY,CAChC,IAAI,EAAE,cAAc,EACpB,IAAI,GAAE,iBAAsB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CA2D3B"}