dorfl 0.0.0 → 0.1.0

package/dist/triage-persist.js

@@ -0,0 +1,387 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { run } from './git.js';
+import { workItemRel } from './work-layout.js';
+import { createItemThroughCas, } from './advancing-lock.js';
+import { resolveSidecarIdentity, sidecarPathFor } from './sidecar.js';
+import { renderTaskBody, renderSpecBody } from './buildable-body.js';
+/**
+ * The engine-owned TRIAGE PERSIST (prd `advance-loop`, task `advance-rung-triage`,
+ * US #16/17/24/30) — the half of the observation-triage rung the ENGINE owns (the
+ * triage gate JUDGES, the engine ACTS). It is the SIBLING of `surface-persist.ts`
+ * (the surface rung's persist) and `apply-persist.ts` (the apply rung's persist),
+ * kept file-orthogonal so the rung bodies land in different tasks.
+ *
+ * It delivers the two WRITES the triage rung needs beyond the always-allowed
+ * question-gated surface path (which reuses `surface-persist.ts` verbatim):
+ *
+ *   1. **the conservative auto-disposition** ({@link autoDispositionObservation},
+ *      US #17, `observationTriage: 'auto'`-gated): act on the no-question case on
+ *      the UNTRIAGED observation in ONE local commit. BOTH no-question cases now
+ *      DISCHARGE the redundant note BY DELETION (there is no resting `triaged:keep`
+ *      state any more — task `agentic-apply-retire-disposition-vocabulary`):
+ *        - `duplicate` → `git rm` the duplicate in a standalone commit, the
+ *          duplicated-of identity + reason in the commit message (git history =
+ *          archive). A duplicate is a redundant copy of an already-captured signal,
+ *          so deleting it loses nothing; or
+ *        - `map` → the note is already covered by the existing item it maps onto, so
+ *          it is settled — `git rm` it in a standalone commit, the mapped-onto
+ *          identity + reason recorded in the commit message (mirroring `duplicate`).
+ *          There is no resting `triaged:keep` note any more.
+ *   2. **promote → SELF-CONTAINED new-item creation + DELETE through the CAS**
+ *      ({@link promoteObservation}, US #1/#3/#8): an ANSWERED "promote" drafts a
+ *      new `work/tasks/ready/<new-slug>.md` whose body is built FROM the
+ *      observation (mechanism + fix prose into `## What to build`, the
+ *      `## Open questions` scoping transcribed, `needsAnswers` set when questions
+ *      remain), routed THROUGH the CAS keyed on the NEW item's identity (its
+ *      target path) — so the (unlikely) same-slug new-item race needs NO special
+ *      case (the loser fails the CAS and backs off). On a WIN the observation +
+ *      its answered sidecar are `git rm`-ed IN THE SAME atomic create commit
+ *      (discharge by DELETION; the human's ratified "promote" answer authors it),
+ *      so a crash never strands the note without its successor.
+ *
+ * Like its sibling persists, the auto-disposition is a LOCAL one-commit primitive
+ * over a working tree (the throwaway-git-repo test pattern); the CAS-create (now
+ * carrying the note+sidecar deletion in the SAME commit) is the ONLY arbiter race
+ * (it IS the new-item-creation CAS helper from `advancing-lock-borrow`). The
+ * `advancing` CAS lock that makes the triage rung WINNER-ONLY on the OBSERVATION
+ * is held by `performAdvance` BEFORE this is called.
+ *
+ * **NEVER auto-deletes a NON-duplicate signal; NEVER auto-promotes a judgement
+ * call (US #17).** The auto-disposition is bounded to `duplicate`/`map` (the gate's
+ * high bar). A `duplicate` IS discharged by deletion (it is a redundant copy of an
+ * already-captured signal — deleting it loses nothing, the original carries the
+ * signal), which is NOT "auto-deleting a live signal". Promotion is ALWAYS a human
+ * answer (the apply path), never an auto-disposition.
+ */
+function gitSoft(args, cwd, env) {
+    return run('git', args, cwd, { env });
+}
+function gitHard(args, cwd, env) {
+    const result = run('git', args, cwd, { env });
+    if (result.status !== 0) {
+        throw new TriagePersistError(`git ${args.join(' ')} failed (exit ${result.status}): ${result.stderr.trim()}`);
+    }
+    return result;
+}
+function resolveBy(cwd, env) {
+    const name = gitSoft(['config', 'user.name'], cwd, env);
+    if (name.status === 0 && name.stdout.trim() !== '') {
+        return name.stdout.trim();
+    }
+    const e = env ?? process.env;
+    return e.USER ?? e.USERNAME ?? '';
+}
+/** Read the observation body from the tree (committed) then the working file. */
+function readItem(cwd, itemPath, env) {
+    const show = gitSoft(['show', `:${itemPath}`], cwd, env);
+    if (show.status === 0) {
+        return show.stdout;
+    }
+    try {
+        return readFileSync(join(cwd, itemPath), 'utf8');
+    }
+    catch {
+        throw new TriagePersistError(`cannot read observation body for '${itemPath}' (the triage rung needs the item file)`);
+    }
+}
+/** Raised for usage errors (a missing repo, an unreadable observation). */
+export class TriagePersistError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TriagePersistError';
+    }
+}
+/**
+ * Execute a CONSERVATIVE auto-disposition on an UNTRIAGED observation (US #17),
+ * ONE local commit, no question surfaced. BOTH no-question cases DISCHARGE the
+ * redundant note BY DELETION (`git rm` in a STANDALONE commit, the mapped/
+ * duplicated-of identity + reason in the commit message; git history = archive).
+ * There is no resting `triaged:keep` state any more (task
+ * `agentic-apply-retire-disposition-vocabulary` — a signal is still-open,
+ * acted-on, or deleted):
+ *
+ *   - `duplicate` → the note is an EXACT duplicate of `existing` (already
+ *     captured); the original carries the signal, so the copy is deleted; or
+ *   - `map` → the note maps UNAMBIGUOUSLY onto `existing` (already covered there),
+ *     so it is settled — deleted, the mapping recorded in the commit message
+ *     (mirroring `duplicate`).
+ *
+ * It NEVER promotes (promotion is a human "worth building?" answer, the apply path)
+ * and NEVER auto-deletes a NON-redundant signal (the gate's high bar bounds it to
+ * `duplicate`/`map`, both of which carry no unique signal).
+ */
+export function autoDispositionObservation(options) {
+    const { cwd, item, itemPath, kind, existing, env } = options;
+    const note = options.note ?? (() => { });
+    if (gitSoft(['rev-parse', '--git-dir'], cwd, env).status !== 0) {
+        throw new TriagePersistError('not inside a git repository');
+    }
+    const reason = options.reason?.trim() ?? '';
+    const by = options.by || resolveBy(cwd, env);
+    // DISCHARGE BY DELETION (both cases): `git rm` the redundant note in a STANDALONE
+    // commit (no spawned artifact), the relationship + reason in the commit message.
+    // No body marker, no `triaged:` stamp — the note is out of the pool by being gone.
+    gitHard(['rm', '--quiet', '--', itemPath], cwd, env);
+    const relationship = kind === 'duplicate'
+        ? `an EXACT duplicate of ${existing} (already captured; the original carries the signal`
+        : `mapped UNAMBIGUOUSLY onto ${existing} (already covered there; the existing item carries the signal`;
+    const subject = `advance: triage ${item} → ${kind} (by ${by})`;
+    const messageBody = `Discharged by deletion: ${relationship}, git history is the archive).` +
+        (reason !== '' ? `\n\nreason: ${reason}` : '');
+    gitHard(['commit', '--quiet', '-m', subject, '-m', messageBody], cwd, env);
+    const commit = gitHard(['rev-parse', 'HEAD'], cwd, env).stdout.trim();
+    const message = `auto-triaged ${item} → ${kind} of ${existing}: DELETED the note in a ` +
+        'standalone commit (relationship + reason in the commit message, git history is the archive).';
+    note(message);
+    return { outcome: 'deleted', commit, itemPath, message };
+}
+/**
+ * Promote an ANSWERED observation to a NEW, SELF-CONTAINED artifact (US #1/#3/#8
+ * for the task route; US #4/#9 for the PRD route): CAS-create the new item keyed
+ * on the NEW item's identity (its target path), with the observation note + its
+ * answered sidecar `git rm`-ed IN THE SAME atomic commit. Promote is ONE commit
+ * (create + delete).
+ *
+ * The artifact TYPE (`options.artifact`) selects the target + body shape: `'task'`
+ * (default) mints `work/tasks/ready/<slug>.md`; `'prd'` mints
+ * `work/prds/proposed/<slug>.md` (PRD staging — a human later promotes it to
+ * `ready/`). BOTH routes use the SAME triage-local {@link createItemThroughCas}
+ * writer (NOT intake's `switchToWorkBranch`/`performIntegration` branch+integrate
+ * band, which is intake's standalone front door): one create/integrate surface for
+ * triage, the CAS-loser-backs-off guarantee uniform across task and PRD promotion.
+ *
+ * The minted body is built FROM the observation (see {@link buildPromotedBody}):
+ * its mechanism + fix prose is carried into the artifact's lead section (`## What
+ * to build` for a task, `## Problem Statement` for a PRD), and its
+ * `## Open questions` scoping is transcribed into the new item's own
+ * `## Open questions` block with `needsAnswers` set when questions remain (cleared
+ * when none do) — so an agent can build from the artifact ALONE and no decision
+ * residue is lost on deletion. This self-containment is the PRECONDITION for the
+ * same-commit deletion.
+ *
+ * The CAS-create is the new-item-creation helper from `advancing-lock-borrow`
+ * ({@link createItemThroughCas}): a same-slug new-item race needs NO special case
+ * — exactly one creator lands the file, the LOSER fails the CAS (exit 2) and backs
+ * off WITHOUT deleting the observation (so a retry can re-promote). The observation
+ * (+ its sidecar) is deleted ONLY on a WIN, riding the winning creator's commit.
+ */
+export async function promoteObservation(options) {
+    const { cwd, item, itemPath, env } = options;
+    const note = options.note ?? (() => { });
+    const { slug: obsSlug } = resolveSidecarIdentity(item);
+    const newSlug = (options.newSlug ?? obsSlug).trim();
+    const artifact = options.artifact ?? 'task';
+    if (newSlug === '') {
+        return {
+            outcome: 'usage-error',
+            exitCode: 1,
+            message: `promote ${item}: empty new slug — cannot draft a ${artifact}`,
+        };
+    }
+    // Branch the target on artifact TYPE: `task` → the agent pool (`tasks-ready`);
+    // `spec` → SPEC STAGING (`specs-proposed`), the conservative default a human later
+    // promotes to `ready/`. Both still go through the SAME createItemThroughCas
+    // writer below — only the destination folder + body shape differ.
+    const newItemPath = workItemRel(artifact === 'spec' ? 'specs-proposed' : 'tasks-ready', `${newSlug}.md`);
+    const by = options.by || resolveBy(cwd, env);
+    const content = ensureTaskDispatchable(artifact, newSlug, options.stubContent ??
+        buildPromotedBody(artifact, newSlug, readItem(cwd, itemPath, env)));
+    // The note + its answered sidecar `git rm` IN THE SAME create commit (promote =
+    // ONE atomic commit). A CAS LOSER never reaches the commit, so it leaves both
+    // INTACT for a retry (today's loser-backs-off guarantee, now over deletion).
+    const sidecarPath = sidecarPathFor(item);
+    // CAS-CREATE the new task keyed on its identity, carrying the note+sidecar
+    // deletion in the SAME commit. A same-slug race ⇒ the loser fails here and
+    // backs off WITHOUT deleting the observation.
+    const created = await createItemThroughCas({
+        path: newItemPath,
+        content,
+        deletePaths: [itemPath, sidecarPath],
+        cwd,
+        arbiter: options.arbiter,
+        by,
+        dryRun: options.dryRun,
+        env,
+        note,
+        ...(options.contention !== undefined
+            ? { contention: options.contention }
+            : {}),
+    });
+    if (created.exitCode !== 0) {
+        const message = `promote ${item}: the new item ${newItemPath} ${created.outcome} the ` +
+            `create CAS (${created.message}) — backing off, the observation is left ` +
+            'intact for a retry.';
+        note(message);
+        return {
+            outcome: created.outcome === 'lost' ? 'lost' : 'contended',
+            exitCode: created.exitCode,
+            message,
+        };
+    }
+    const message = `promoted ${item} → CREATED ${newItemPath} (via the CAS) + DELETED the ` +
+        'observation + its sidecar in the same commit.';
+    note(message);
+    return { outcome: 'promoted', exitCode: 0, newItemPath, message };
+}
+/**
+ * Build a SELF-CONTAINED body from a promoted observation. The observation's body
+ * (its mechanism + fix prose) is lifted into the artifact's LEAD section; its
+ * `## Open questions` section — if any — is SPLIT OUT and transcribed into the new
+ * item's own `## Open questions` block, and `needsAnswers: true` is stamped iff
+ * that block carries content (so deleting the note loses no scoping residue).
+ *
+ * The artifact TYPE selects the frontmatter + lead heading: a `task` gets
+ * `## What to build` + `blockedBy: []` + a `## Prompt` (the buildable-task shape);
+ * a `prd` gets `## Problem Statement` (the PRD document shape, with no `blockedBy` —
+ * a PRD is not a blockable task — and no `## Prompt`, since a PRD is not
+ * dispatched by `do`/`run`). BOTH carry the SAME transcribed mechanism prose +
+ * open-question block, so a PRD minted into `proposed/` is just as self-contained
+ * as a task.
+ *
+ * The `## Prompt` (task only) is the STRUCTURAL dispatchability the validator
+ * `resolveTask`/`extractPromptSection` (`prompt.ts`) requires: without it a
+ * dispatched build throws "has no '## Prompt' section". The body BELOW the
+ * frontmatter (lead section + mechanism prose + optional `## Open questions` +
+ * the task-only `## Prompt`) is rendered by the SHARED owner of the
+ * buildable-task/PRD schema, {@link renderTaskBody} / {@link renderSpecBody}
+ * (`buildable-body.ts`), so the producer and the consumer cannot drift apart
+ * (prd `centralize-buildable-task-renderer-shared-by-intake-and-promotion`,
+ * US #3/#5/#6). This function owns only the FRONTMATTER writer; the section
+ * skeleton lives in the one renderer. The empty-mechanism `## Prompt` seed is
+ * passed EXPLICITLY (`Build the task '<slug>', described above.`) so promotion's
+ * output is byte-for-byte unchanged — it differs from the renderer's generic
+ * `Build the task described above.` default.
+ *
+ * Composition rule (recorded in the done record `## Decisions`): the split point
+ * is the observation's FIRST `## Open questions` heading (any later sibling text
+ * up to the next same-level heading, or EOF, is the scoping). Everything BEFORE it
+ * is the mechanism/fix prose. We copy PROSE (not a back-pointer) so the artifact is
+ * buildable on its own.
+ */
+/**
+ * Guarantee a minted TASK body is DISPATCHABLE (carries a `## Prompt`). The
+ * agentic apply path (`apply-decide` → `promoteObservation` with `stubContent`)
+ * lets a fresh-context agent AUTHOR the task body, and that agent frequently omits
+ * the `## Prompt` section (drafting its own `## Context`/`## Definition of done`
+ * skeleton instead) — so the raw drafted body bypasses {@link buildPromotedBody}'s
+ * renderer and lands NON-dispatchable: the `advance --propose` build leg then
+ * fails with `has no '## Prompt' section` (the `extractPromptSection`/`resolveTask`
+ * guard in `prompt.ts`). This is the robust backstop that closes that hole
+ * regardless of agent compliance: for a TASK, if the body has no `## Prompt`
+ * heading, append a seeded one (blockquoted, matching the renderer's shape). A PRD
+ * is left UNTOUCHED — a PRD is a north-star doc, not dispatched by `do`/`run`, and carries no
+ * `## Prompt` by design.
+ */
+function ensureTaskDispatchable(artifact, slug, body) {
+    if (artifact === 'spec') {
+        return body;
+    }
+    // A task WITH a `## Prompt` heading (any level-2 spelling the validator matches)
+    // is already dispatchable — leave it byte-for-byte.
+    if (/^##\s+Prompt\b/im.test(body)) {
+        return body;
+    }
+    // No `## Prompt`: append a seeded, blockquoted one so the minted task never
+    // lands non-dispatchable. The seed points the builder at the body above (the
+    // same shape `renderTaskBody`'s empty-mechanism default uses).
+    const trimmed = body.replace(/\s+$/, '');
+    const seed = `Build the task '${slug}', described above.`;
+    const promptBlock = `## Prompt\n\n> ${seed}\n`;
+    return `${trimmed}\n\n${promptBlock}`;
+}
+function buildPromotedBody(artifact, slug, observation) {
+    const { mechanism, openQuestions } = splitObservationBody(observation);
+    const hasQuestions = openQuestions.trim() !== '';
+    const frontmatter = [
+        '---',
+        `title: ${slug}`,
+        `slug: ${slug}`,
+        `needsAnswers: ${hasQuestions ? 'true' : 'false'}`,
+        // A PRD is a north-star doc, not a blockable task — only the task shape carries
+        // `blockedBy`.
+        ...(artifact === 'spec' ? [] : ['blockedBy: []']),
+        '---',
+    ];
+    // One BLANK line separates the closing frontmatter fence from the rendered
+    // body (`---\n\n## ...`): the shared renderer starts AT its first heading with no
+    // leading blank, so the separator is owned here. This keeps promotion's output
+    // byte-for-byte identical to the pre-rewire hand-rolled body (which placed an
+    // empty array element between the `---` fence and the lead heading) and matches
+    // what intake will emit once it adopts the same renderer. RATIFIED as a
+    // cross-module convention in `docs/adr/frontmatter-owns-fence-to-heading-blank-line.md`
+    // — frontmatter owns the `\n\n`, the renderer starts at the first heading with
+    // no leading blank. Do NOT move the separator into the renderer.
+    const fenceToBody = frontmatter.join('\n') + '\n\n';
+    // The body BELOW the frontmatter is rendered by the SHARED schema owner so the
+    // section skeleton has one home, not two (prd
+    // `centralize-buildable-task-renderer-shared-by-intake-and-promotion`). A PRD
+    // goes through `renderSpecBody` (no `## Prompt`); a task through
+    // `renderTaskBody` (always a `## Prompt`).
+    if (artifact === 'spec') {
+        return (fenceToBody +
+            renderSpecBody({
+                problemStatement: mechanism,
+                openQuestions,
+            }));
+    }
+    // Pass the slug-bearing empty-mechanism seed EXPLICITLY: the renderer's generic
+    // default is `Build the task described above.`, but promotion has always seeded
+    // the empty-mechanism case with the slug (`Build the task '<slug>', described
+    // above.`), so we keep that byte-for-byte by handing the seed in rather than
+    // relying on the renderer default. A non-empty mechanism seeds the `## Prompt`
+    // from the mechanism prose (the renderer blockquotes it).
+    const promptSeed = mechanism.trim() === ''
+        ? `Build the task '${slug}', described above.`
+        : mechanism;
+    return (fenceToBody +
+        renderTaskBody({
+            whatToBuild: mechanism,
+            openQuestions,
+            prompt: promptSeed,
+        }));
+}
+/**
+ * Split an observation's text into its mechanism/fix PROSE (before the first
+ * `## Open questions` heading) and its open-questions SCOPING (that section's
+ * body, up to the next `## ` heading or EOF). The frontmatter fence is dropped
+ * (the new task gets its own). When there is no `## Open questions` heading the
+ * whole body is mechanism and the scoping is empty.
+ */
+function splitObservationBody(observation) {
+    const body = stripFrontmatter(observation);
+    const lines = body.split('\n');
+    // Match `## Open questions` (and tolerant variants like
+    // `## Open questions to NOT guess` the capture-signal skill writes).
+    const startIdx = lines.findIndex((l) => /^##\s+Open questions\b/i.test(l));
+    if (startIdx === -1) {
+        return { mechanism: body, openQuestions: '' };
+    }
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (/^##\s+/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    const mechanism = lines.slice(0, startIdx).join('\n');
+    const openQuestions = lines.slice(startIdx + 1, endIdx).join('\n');
+    return { mechanism, openQuestions };
+}
+/** Strip a leading `---\n…\n---` frontmatter fence, returning the body. */
+function stripFrontmatter(content) {
+    const normalized = content.replace(/\r\n/g, '\n').replace(/^\uFEFF/, '');
+    if (!normalized.startsWith('---\n')) {
+        return normalized;
+    }
+    const lines = normalized.split('\n');
+    const closing = lines.indexOf('---', 1);
+    if (closing === -1) {
+        return normalized;
+    }
+    return lines
+        .slice(closing + 1)
+        .join('\n')
+        .replace(/^\n+/, '');
+}
+//# sourceMappingURL=triage-persist.js.map

package/dist/triage-persist.js.map

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

package/dist/verdict-json.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The SHARED "first JSON object in agent prose" extractor — the single
+ * implementation behind every prompt→verdict→dispatch seam in this package
+ * (the Gate-2 PR/code review gate and the task-SET acceptance gate in
+ * `review-gate.ts`, the tasker IMPROVER loop in `tasker-review-loop.ts`, and the
+ * issue-intake decision in `intake.ts`). Each of those launches an agent that
+ * EMITS a single JSON object (possibly fenced / wrapped in prose) and the runner
+ * pulls it back out to dispatch on it — the SAME need, so it is ONE extractor, not
+ * a forked copy per caller (coherence; task `intake-production-verdict-parse`).
+ *
+ * The only thing that varies between callers is the DISCRIMINATOR KEY they brace-
+ * match outward from: the review gates emit `{"verdict": …}`, intake emits
+ * `{"outcome": …}`. {@link extractJsonObjectSpan} takes that key as a parameter
+ * (defaulting to `"verdict"` so the review-gate callers read identically).
+ */
+/**
+ * Locate the first JSON object that carries a `"<key>"` field in arbitrary agent
+ * output (it may be fenced, prefixed with prose, or bare), returning its `[start,
+ * end)` span (`output.slice(start, end)` is the JSON). Brace-matched from the
+ * `"<key>"` occurrence OUTWARD (walk back to the enclosing `{`, then brace-match
+ * forward, respecting strings) so a surrounding fence / prose does not defeat
+ * parsing. Returns `undefined` when none is found.
+ *
+ * @param output the agent's raw textual output.
+ * @param key the discriminator field name to anchor on, WITHOUT quotes
+ *   (defaults to `verdict`, the review gates' key; intake passes `outcome`).
+ */
+export declare function extractJsonObjectSpan(output: string, key?: string): {
+    start: number;
+    end: number;
+} | undefined;
+//# sourceMappingURL=verdict-json.d.ts.map

package/dist/verdict-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict-json.d.ts","sourceRoot":"","sources":["../src/verdict-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,MAAM,EACd,GAAG,SAAY,GACb;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,GAAG,SAAS,CAyC1C"}

package/dist/verdict-json.js

@@ -0,0 +1,74 @@
+/**
+ * The SHARED "first JSON object in agent prose" extractor — the single
+ * implementation behind every prompt→verdict→dispatch seam in this package
+ * (the Gate-2 PR/code review gate and the task-SET acceptance gate in
+ * `review-gate.ts`, the tasker IMPROVER loop in `tasker-review-loop.ts`, and the
+ * issue-intake decision in `intake.ts`). Each of those launches an agent that
+ * EMITS a single JSON object (possibly fenced / wrapped in prose) and the runner
+ * pulls it back out to dispatch on it — the SAME need, so it is ONE extractor, not
+ * a forked copy per caller (coherence; task `intake-production-verdict-parse`).
+ *
+ * The only thing that varies between callers is the DISCRIMINATOR KEY they brace-
+ * match outward from: the review gates emit `{"verdict": …}`, intake emits
+ * `{"outcome": …}`. {@link extractJsonObjectSpan} takes that key as a parameter
+ * (defaulting to `"verdict"` so the review-gate callers read identically).
+ */
+/**
+ * Locate the first JSON object that carries a `"<key>"` field in arbitrary agent
+ * output (it may be fenced, prefixed with prose, or bare), returning its `[start,
+ * end)` span (`output.slice(start, end)` is the JSON). Brace-matched from the
+ * `"<key>"` occurrence OUTWARD (walk back to the enclosing `{`, then brace-match
+ * forward, respecting strings) so a surrounding fence / prose does not defeat
+ * parsing. Returns `undefined` when none is found.
+ *
+ * @param output the agent's raw textual output.
+ * @param key the discriminator field name to anchor on, WITHOUT quotes
+ *   (defaults to `verdict`, the review gates' key; intake passes `outcome`).
+ */
+export function extractJsonObjectSpan(output, key = 'verdict') {
+    const anchor = output.indexOf(`"${key}"`);
+    if (anchor === -1) {
+        return undefined;
+    }
+    // Walk back to the opening brace of the object containing the key.
+    let start = anchor;
+    while (start >= 0 && output[start] !== '{') {
+        start--;
+    }
+    if (start < 0) {
+        return undefined;
+    }
+    // Brace-match forward from that opening brace, respecting strings.
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < output.length; i++) {
+        const ch = output[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (ch === '\\') {
+                escaped = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+        }
+        else if (ch === '{') {
+            depth++;
+        }
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0) {
+                return { start, end: i + 1 };
+            }
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=verdict-json.js.map

package/dist/verdict-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict-json.js","sourceRoot":"","sources":["../src/verdict-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,qBAAqB,CACpC,MAAc,EACd,GAAG,GAAG,SAAS;IAEf,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC;IAC1C,IAAI,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC;QACnB,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,mEAAmE;IACnE,IAAI,KAAK,GAAG,MAAM,CAAC;IACnB,OAAO,KAAK,IAAI,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;QAC5C,KAAK,EAAE,CAAC;IACT,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACf,OAAO,SAAS,CAAC;IAClB,CAAC;IACD,mEAAmE;IACnE,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5C,MAAM,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACrB,IAAI,QAAQ,EAAE,CAAC;YACd,IAAI,OAAO,EAAE,CAAC;gBACb,OAAO,GAAG,KAAK,CAAC;YACjB,CAAC;iBAAM,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC;gBACxB,OAAO,GAAG,IAAI,CAAC;YAChB,CAAC;iBAAM,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;gBACvB,QAAQ,GAAG,KAAK,CAAC;YAClB,CAAC;YACD,SAAS;QACV,CAAC;QACD,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YAChB,QAAQ,GAAG,IAAI,CAAC;QACjB,CAAC;aAAM,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YACvB,KAAK,EAAE,CAAC;QACT,CAAC;aAAM,IAAI,EAAE,KAAK,GAAG,EAAE,CAAC;YACvB,KAAK,EAAE,CAAC;YACR,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;gBACjB,OAAO,EAAC,KAAK,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAC,CAAC;YAC5B,CAAC;QACF,CAAC;IACF,CAAC;IACD,OAAO,SAAS,CAAC;AAClB,CAAC"}

package/dist/verify-workflow-template.d.ts

@@ -0,0 +1,60 @@
+/**
+ * The `install-ci` VERIFY-WORKFLOW capability (prd
+ * `land-time-reverify-and-parallel-merge-ceiling`, task
+ * `install-ci-tier1-branch-protection`; Story 11 — the Tier-1 GitHub ceiling).
+ * Emits a small `verify.yml` workflow whose ONLY job is `verify` and runs on
+ * `pull_request` (and `merge_group`, the Tier-2 forward seam). It produces the
+ * GitHub check named exactly {@link VERIFY_CHECK_CONTEXT}, which the
+ * branch-protection step ({@link installCIBranchProtectionStep}) names as the
+ * required-status check `context`. Co-locating the two strings — the EMITTED
+ * job/check name AND the REQUIRED context — in one constant pins the
+ * acceptance-criterion "context matches the workflow's job name" by construction
+ * (a single test diffs the two).
+ *
+ * The workflow is deliberately thin: it wires the same composite setup action
+ * the other capabilities use, then runs `dorfl verify` — the deterministic shell
+ * gate the repo declares in `.dorfl.json`. No agent, no provider secrets, no
+ * `gh` mutation; it is read-only with respect to `work/`.
+ *
+ * `merge_group` is present (with no extra wiring) so a follow-on Tier-2 task
+ * (GitHub Merge Queue) can flip the ruleset on without changing this workflow's
+ * trigger surface — the forward seam the spec's Applied Answers q3 names.
+ */
+import type { ResolvedCIConfig } from './install-ci-core.js';
+/**
+ * The required-status-check CONTEXT install-ci sets via branch protection AND the
+ * job/check name the emitted verify workflow produces. ONE source of truth so
+ * the two strings can never drift (the "context matches the workflow's job name"
+ * acceptance criterion is enforced by both reading this constant).
+ */
+export declare const VERIFY_CHECK_CONTEXT = "verify";
+/** The capability id (the registry key + the emitted workflow file stem). */
+export declare const VERIFY_CAPABILITY_ID = "verify";
+/** The wizard-facing label for the verify capability. */
+export declare const VERIFY_CAPABILITY_LABEL = "Run the repo `verify` gate on every PR (the Tier-1 GitHub ceiling: produces the required-status check `verify` that branch protection requires)";
+/** The repo-relative path (under the output base) of the emitted workflow. */
+export declare const VERIFY_WORKFLOW_PATH = "workflows/verify.yml";
+/**
+ * Generate the verify workflow YAML. Deterministic: the same config produces
+ * byte-identical output. The job is named exactly {@link VERIFY_CHECK_CONTEXT}
+ * so the GitHub check it produces matches the required-status `context` install-ci
+ * configures on `main` — by construction, not by hand-typed agreement.
+ */
+export declare function generateVerifyWorkflow(_config: ResolvedCIConfig): string;
+/** A single structural problem found in the generated verify workflow. */
+export interface VerifyWorkflowProblem {
+    id: string;
+    message: string;
+}
+/** Result of {@link validateVerifyWorkflow}. */
+export interface VerifyWorkflowValidation {
+    ok: boolean;
+    problems: VerifyWorkflowProblem[];
+}
+/**
+ * Structurally validate the verify workflow against the task's acceptance
+ * criteria (job name = required context, runs on `pull_request`, ships the
+ * `merge_group` seam, no `workflows:` permission).
+ */
+export declare function validateVerifyWorkflow(text: string): VerifyWorkflowValidation;
+//# sourceMappingURL=verify-workflow-template.d.ts.map

package/dist/verify-workflow-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-workflow-template.d.ts","sourceRoot":"","sources":["../src/verify-workflow-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAE7C,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAE7C,yDAAyD;AACzD,eAAO,MAAM,uBAAuB,oJAC8G,CAAC;AAEnJ,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,yBAAyB,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,MAAM,CA4DxE;AAED,0EAA0E;AAC1E,MAAM,WAAW,qBAAqB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,gDAAgD;AAChD,MAAM,WAAW,wBAAwB;IACxC,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,qBAAqB,EAAE,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,wBAAwB,CA8B7E"}