dorfl 0.0.0 → 0.1.0

package/dist/intake-marker.js

@@ -0,0 +1,127 @@
+import { brand } from './brand.js';
+/** The marker's brand-derived namespace token (today `dorfl:intake`). */
+const MARKER_NS = `${brand.base}:intake`;
+/**
+ * Matches ONE intake marker anywhere in a comment body (the hidden HTML comment).
+ * Captures the inner attribute run (everything after the namespace, before `-->`)
+ * so {@link parseIntakeMarker} can pull `kind` / `slug` / `seen` out of it. Global
+ * so a body that (pathologically) carries more than one is fully scanned, though
+ * intake stamps exactly one per comment.
+ */
+const MARKER_RE = new RegExp(`<!--\\s*${escapeRegExp(MARKER_NS)}\\s+([^>]*?)\\s*-->`, 'g');
+/**
+ * STAMP the intake marker onto a comment body intake is about to post (the SHARED
+ * producer for ALL of ask / bounced / created). Appends the hidden HTML comment
+ * AFTER the human-readable text, separated by a blank line, so the rendered comment
+ * is just the text (the marker is invisible) yet the raw markdown carries the
+ * marker for the triage to recover.
+ *
+ * `seen` is the per-run DELTA of human comment ids (computed by
+ * {@link computeSeenDelta}); it is emitted even when empty (`seen=`) so the grammar
+ * is uniform and the parser never has to special-case its absence. `slug` is
+ * emitted only for `kind=created`.
+ */
+export function stampIntakeMarker(body, marker) {
+    const parts = [`kind=${marker.kind}`];
+    if (marker.kind === 'created' &&
+        marker.slug !== undefined &&
+        marker.slug !== '') {
+        parts.push(`slug=${marker.slug}`);
+    }
+    parts.push(`seen=${marker.seen.join(',')}`);
+    const tag = `<!-- ${MARKER_NS} ${parts.join(' ')} -->`;
+    const text = body.replace(/\s+$/, '');
+    return text === '' ? tag : `${text}\n\n${tag}`;
+}
+/**
+ * Parse the FIRST intake marker out of a comment body (the SHARED consumer). Returns
+ * `undefined` when the body carries no intake marker \u2014 i.e. it is a HUMAN comment
+ * (the triage ranges its unseen-check over exactly these). A malformed marker (no
+ * `kind`, or an unknown `kind`) is treated as ABSENT rather than throwing: an
+ * unparseable hidden comment must never make the triage crash or misclassify a
+ * human comment as intake's.
+ */
+export function parseIntakeMarker(body) {
+    MARKER_RE.lastIndex = 0;
+    const match = MARKER_RE.exec(body);
+    if (match === null) {
+        return undefined;
+    }
+    const attrs = match[1];
+    const kind = readAttr(attrs, 'kind');
+    if (kind !== 'ask' && kind !== 'bounced' && kind !== 'created') {
+        return undefined;
+    }
+    const slug = readAttr(attrs, 'slug');
+    const seenRaw = readAttr(attrs, 'seen');
+    const seen = seenRaw === undefined || seenRaw === ''
+        ? []
+        : seenRaw.split(',').filter((id) => id !== '');
+    return {
+        kind,
+        seen,
+        ...(slug !== undefined && slug !== '' ? { slug } : {}),
+    };
+}
+/** True iff the comment carries an intake marker \u2014 i.e. it is INTAKE's OWN comment. */
+export function isIntakeComment(comment) {
+    return parseIntakeMarker(comment.body) !== undefined;
+}
+/**
+ * Compute the per-run `seen=` DELTA for a marker intake is about to stamp: the ids
+ * of the HUMAN comments in the thread as intake READ it, EXCLUDING (a) intake's own
+ * marker-comments (identified by carrying a marker) and (b) any human id ALREADY
+ * recorded in a prior intake marker's `seen=` (the chain model keeps each marker's
+ * `seen=` a bounded per-run delta; the union reconstructs the whole). Order follows
+ * `listComments`' oldest-first; ids with no value (a provider that omitted one) are
+ * dropped \u2014 the triage only reasons over ids it actually has.
+ */
+export function computeSeenDelta(comments) {
+    const already = seenSetFrom(comments);
+    const delta = [];
+    for (const comment of comments) {
+        if (isIntakeComment(comment)) {
+            continue; // intake's own marker-comment \u2014 NEVER recorded in `seen=`.
+        }
+        const id = comment.id;
+        if (id === undefined || id === '') {
+            continue;
+        }
+        if (already.has(id) || delta.includes(id)) {
+            continue;
+        }
+        delta.push(id);
+    }
+    return delta;
+}
+/**
+ * Build the full `seenSet` for the TRIAGE: the UNION of every intake marker's
+ * `seen=` id-list in the thread (the chain model \u2014 each marker stores a per-run
+ * delta, the union reconstructs the complete set of human comments intake has EVER
+ * read). Ranges over intake's OWN comments (the ones carrying a marker); a human
+ * comment never carries a `seen=`.
+ */
+export function seenSetFrom(comments) {
+    const set = new Set();
+    for (const comment of comments) {
+        const marker = parseIntakeMarker(comment.body);
+        if (marker === undefined) {
+            continue;
+        }
+        for (const id of marker.seen) {
+            set.add(id);
+        }
+    }
+    return set;
+}
+/** Read a `key=value` attribute out of a marker's inner attribute run. */
+function readAttr(attrs, key) {
+    const re = new RegExp(`(?:^|\\s)${escapeRegExp(key)}=([^\\s]*)`);
+    const match = re.exec(attrs);
+    return match === null ? undefined : match[1];
+}
+/** Escape a literal for embedding in a RegExp (the brand base + attribute keys). */
+function escapeRegExp(literal) {
+    return literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=intake-marker.js.map

package/dist/intake-marker.js.map

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

package/dist/intake-triage.d.ts

@@ -0,0 +1,48 @@
+import type { IssueComment } from './issue-provider.js';
+/**
+ * The TRIAGE outcome. `proceed` runs the prompt (optionally carrying enrichment
+ * flags for the prompt); `no-new-input` / `already-terminal` are SKIPS (siblings of
+ * `locked` \u2014 "ran, deliberately did nothing", both exit 0, observable by CI + a
+ * human).
+ */
+export type IntakeTriageDecision = {
+    action: 'proceed';
+    /**
+     * Enrichment for the prompt on the PROCEED path. `predatingIds` are HUMAN
+     * comment ids that RACED IN (read-then-someone-commented-then-posted) \u2014 they
+     * PRE-DATE intake's last turn, so the prompt treats them as context for a
+     * PRIOR state, not necessarily a fresh answer. `deletedSeenCount` is the count
+     * of previously-SEEN human comments that have since been DELETED (computed
+     * ONLY on this raced proceed path \u2014 deletion is enrichment, never a wake
+     * trigger), flagged so the prompt does not assume its prior premises still
+     * hold. Both are absent/zero on the ordinary fresh/mid-ask proceed.
+     */
+    predatingIds: string[];
+    deletedSeenCount: number;
+} | {
+    action: 'skip';
+    outcome: 'no-new-input' | 'already-terminal';
+};
+/**
+ * Run the TRIAGE over the issue's full comment thread (oldest-first, as
+ * `listComments` returns it). The canonical branches (prd `issue-intake`):
+ *
+ * 1. **Last comment is INTAKE's** (carries a marker). Build `seenSet` = the UNION of
+ *    every intake marker's `seen=` id-list, then:
+ *    - **PRIMARY** \u2014 is there an UNSEEN HUMAN comment (one WITHOUT a marker whose id
+ *      is NOT in `seenSet`)? \u2192 PROCEED. The raced comment(s) are flagged as
+ *      PRE-DATING intake's last turn. ALSO compute `seenSet \u2212 currentHumanThreadIds`;
+ *      a non-empty difference means a previously-seen human comment was DELETED \u2014
+ *      flagged (count only) so the prompt reassesses. (Deletion is ENRICHMENT on this
+ *      proceed path only, NEVER a standalone wake trigger.)
+ *    - **otherwise** (every human comment is in `seenSet`) \u2192 SKIP `no-new-input`. No
+ *      deletion hunt here \u2014 a deletion with no new comment is not a turn worth waking
+ *      for. This is what makes intake SELF-TRIGGERING a no-op by construction.
+ * 2. **Last comment is someone ELSE's** (no marker on the last comment):
+ *    - the thread already contains a TERMINAL marker (`bounced`/`created`) \u2192 SKIP
+ *      `already-terminal` (the issue was already transformed).
+ *    - otherwise (no terminal marker \u2014 fresh issue, or mid-`ask` loop) \u2192 PROCEED.
+ * 3. **Empty thread** \u2192 PROCEED (a fresh issue with no comments).
+ */
+export declare function triageIntake(comments: IssueComment[]): IntakeTriageDecision;
+//# sourceMappingURL=intake-triage.d.ts.map

package/dist/intake-triage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intake-triage.d.ts","sourceRoot":"","sources":["../src/intake-triage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AA+BtD;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAC7B;IACA,MAAM,EAAE,SAAS,CAAC;IAClB;;;;;;;;;OASG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CACxB,GACD;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,cAAc,GAAG,kBAAkB,CAAA;CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,oBAAoB,CAkD3E"}

package/dist/intake-triage.js

@@ -0,0 +1,95 @@
+import { parseIntakeMarker, seenSetFrom, } from './intake-marker.js';
+/**
+ * **The intake TRIAGE GATE** (task `intake-self-awareness-resumption-tracking`, prd
+ * `issue-intake` US #2/#10): a DETERMINISTIC pre-decision gate that runs UNDER the
+ * processing lock, BEFORE the decision prompt, deciding whether intake should run
+ * the prompt at all. Built ENTIRELY on the thread MARKER (no sidecar, no cursor, no
+ * bot-identity), it makes intake skip when it has the last word or the issue is
+ * already terminal, and run the prompt ONLY on genuine new human input \u2014 which is
+ * also the COMPLETE fix for the self-trigger hazard (intake's own freshly-posted
+ * comment carries a marker, so it is excluded from the human-comment check by
+ * construction).
+ *
+ * The TERMINAL/non-terminal split lives HERE, never in the marker: `ask` is
+ * non-terminal, `bounced`/`created` are terminal. Re-classifying a kind later is a
+ * change to {@link TERMINAL_KINDS} only \u2014 old markers stay valid.
+ *
+ * This is PURE logic over the stubbed thread (no seam, no git, no `gh`), the same
+ * discipline `intake-event.ts` / `failure-cause.ts` keep.
+ */
+/** The kinds the TRIAGE treats as TERMINAL (the issue was already transformed). */
+const TERMINAL_KINDS = new Set(['bounced', 'created']);
+/**
+ * Run the TRIAGE over the issue's full comment thread (oldest-first, as
+ * `listComments` returns it). The canonical branches (prd `issue-intake`):
+ *
+ * 1. **Last comment is INTAKE's** (carries a marker). Build `seenSet` = the UNION of
+ *    every intake marker's `seen=` id-list, then:
+ *    - **PRIMARY** \u2014 is there an UNSEEN HUMAN comment (one WITHOUT a marker whose id
+ *      is NOT in `seenSet`)? \u2192 PROCEED. The raced comment(s) are flagged as
+ *      PRE-DATING intake's last turn. ALSO compute `seenSet \u2212 currentHumanThreadIds`;
+ *      a non-empty difference means a previously-seen human comment was DELETED \u2014
+ *      flagged (count only) so the prompt reassesses. (Deletion is ENRICHMENT on this
+ *      proceed path only, NEVER a standalone wake trigger.)
+ *    - **otherwise** (every human comment is in `seenSet`) \u2192 SKIP `no-new-input`. No
+ *      deletion hunt here \u2014 a deletion with no new comment is not a turn worth waking
+ *      for. This is what makes intake SELF-TRIGGERING a no-op by construction.
+ * 2. **Last comment is someone ELSE's** (no marker on the last comment):
+ *    - the thread already contains a TERMINAL marker (`bounced`/`created`) \u2192 SKIP
+ *      `already-terminal` (the issue was already transformed).
+ *    - otherwise (no terminal marker \u2014 fresh issue, or mid-`ask` loop) \u2192 PROCEED.
+ * 3. **Empty thread** \u2192 PROCEED (a fresh issue with no comments).
+ */
+export function triageIntake(comments) {
+    if (comments.length === 0) {
+        // A fresh issue with no thread \u2014 there is genuine new material (the body).
+        return { action: 'proceed', predatingIds: [], deletedSeenCount: 0 };
+    }
+    const last = comments[comments.length - 1];
+    const lastIsIntake = parseIntakeMarker(last.body) !== undefined;
+    if (lastIsIntake) {
+        // BRANCH 1 \u2014 intake has the last word. Did a human comment race in unseen?
+        const seenSet = seenSetFrom(comments);
+        const humanComments = comments.filter((c) => parseIntakeMarker(c.body) === undefined);
+        const currentHumanIds = new Set(humanComments
+            .map((c) => c.id)
+            .filter((id) => id !== undefined && id !== ''));
+        // PRIMARY: HUMAN comments (markerless) whose id is NOT in seenSet \u2014 raced in.
+        const predatingIds = humanComments
+            .map((c) => c.id)
+            .filter((id) => id !== undefined && id !== '' && !seenSet.has(id));
+        if (predatingIds.length > 0) {
+            // PROCEED on the raced comment(s). DELETION ENRICHMENT (only here): a
+            // previously-seen human id no longer present in the thread was deleted.
+            let deletedSeenCount = 0;
+            for (const id of seenSet) {
+                if (!currentHumanIds.has(id)) {
+                    deletedSeenCount += 1;
+                }
+            }
+            return { action: 'proceed', predatingIds, deletedSeenCount };
+        }
+        // Every human comment is in seenSet \u2014 intake has the last word and saw
+        // everything. SKIP (no deletion hunt: a bare deletion is not a wake trigger).
+        return { action: 'skip', outcome: 'no-new-input' };
+    }
+    // BRANCH 2 \u2014 the last comment is a human's. A terminal marker earlier in the
+    // thread means the issue was already transformed; a later human comment does not
+    // re-open it (a future feature may; for now, skip).
+    if (hasTerminalMarker(comments)) {
+        return { action: 'skip', outcome: 'already-terminal' };
+    }
+    // Fresh issue, or a human reply mid-`ask` loop \u2014 PROCEED to the decision.
+    return { action: 'proceed', predatingIds: [], deletedSeenCount: 0 };
+}
+/** True iff any comment in the thread carries a TERMINAL intake marker. */
+function hasTerminalMarker(comments) {
+    for (const comment of comments) {
+        const marker = parseIntakeMarker(comment.body);
+        if (marker !== undefined && TERMINAL_KINDS.has(marker.kind)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=intake-triage.js.map

package/dist/intake-triage.js.map

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

package/dist/intake-trigger-template.d.ts

@@ -0,0 +1,185 @@
+/**
+ * The `install-ci` ISSUE-INTAKE capability (prd `runner-in-ci`, task
+ * `install-ci-intake-trigger-and-review-surface`; capability D: consider incoming
+ * issues → task/prd, AND insertion point E: surface the review verdict back into
+ * the issue thread). This module GENERATES the one fixed intake workflow file and
+ * STRUCTURALLY VALIDATES it, mirroring the snapshot-assertion style of
+ * `advance-lifecycle-template.ts` / `advance-ci-template.ts` (the package depends on
+ * NO YAML lib, so the checks are presence/shape assertions over the raw text). It
+ * ALSO carries the PURE author-trust → per-outcome-flags DERIVATION
+ * ({@link deriveIntakeFlags}) — CI's merge-vs-propose POLICY, the load-bearing
+ * testable logic the workflow encodes at runtime.
+ *
+ * SCOPE FENCE (prd Out-of-Scope): the issue→artifact TRANSFORM engine is
+ * `issue-intake`'s (`intake <N>` + its four-outcome dispatch + the per-outcome
+ * KNOBS + the lone-task review that posts to the issue thread). CI only
+ * WIRES/SCHEDULES/INVOKES it and owns the merge-vs-propose POLICY + the delivery
+ * surface. This module emits NO transform; it emits the WORKFLOW that calls it.
+ *
+ * The discipline (prd capability-D row + the merge-vs-propose POLICY + the two
+ * RESOLVED design decisions in the task):
+ *
+ *   - TRIGGERS: `issues` opened, `issue_comment` created, and a label
+ *     (`dorfl:intake`). It invokes `intake <N>` (EXPLICIT, four-outcome
+ *     dispatch) — never a bare slug.
+ *   - EVENT→`IntakeEventKind` MAPPING (Decision 2: no edit-detection): only a
+ *     CREATED `issue_comment` (and an opened issue / the label) drives
+ *     (re-)evaluation; an EDITED comment is NOT a trigger (the ID-based
+ *     `seen=<ids>` watermark suffices). The "post a NEW comment to signal an edit"
+ *     convention is documented in the workflow so a human knows to re-trigger.
+ *   - AUTHOR-TRUST → per-outcome FLAGS (Decision 1, {@link deriveIntakeFlags}): an
+ *     UNTRUSTED author (`author_association` not in OWNER/MEMBER/COLLABORATOR)
+ *     forces `--propose-task` REGARDLESS of the `autoBuild` gate, while
+ *     `--merge-spec` stays allowed (a human still tasks a spec before anything
+ *     autonomous acts — the checkpoint is intact). A TRUSTED author gets the plain
+ *     gate-derived mode for both. The fully-gateless "all gates on + merge
+ *     everywhere" path is a LOUD, NON-DEFAULT opt-in — the default is conservative
+ *     (propose / human-in-the-loop).
+ *   - INSERTION POINT E (the issue-thread review surface): the review verdict over
+ *     intake's generated prds/tasks is surfaced into the ISSUE THREAD via the
+ *     `IssueProvider.postIssueComment` seam (issue thread, by NUMBER — NOT the PR
+ *     seam `postPRComment`, which is keyed by url). This is REUSED, not new:
+ *     `intake <N>` already runs the lone-task review/edit loop and posts its
+ *     findings as questions through `postIssueComment`. The workflow surfaces E by
+ *     INVOKING `intake`; it adds no second review mechanism.
+ *   - CI runs IN-PLACE (the CI container IS the isolation): no
+ *     `--isolated`/`--remote`/registry. A PER-ISSUE concurrency group serialises
+ *     overlapping ticks on the SAME issue; the `processing` lock / claim CAS is the
+ *     real cross-run serialiser.
+ *   - The running CI job NEVER edits `.github/workflows/**` (US #9): it requests NO
+ *     `workflows` permission and cannot rewrite its own triggers. It needs
+ *     `contents: write` + `pull-requests: write` (emit/propose the artifact) +
+ *     `issues: write` (post the clarifying/review comment back).
+ *
+ * The structural validator is the dependency-free counterpart of "the workflow
+ * parses + carries the right discipline" the task's acceptance criteria require;
+ * the test generates this artifact under `--fake` and asserts every invariant.
+ */
+import type { ResolvedCIConfig } from './install-ci-core.js';
+/** The capability id (the registry key + the emitted workflow file stem). */
+export declare const INTAKE_TRIGGER_CAPABILITY_ID = "intake";
+/** The wizard-facing label for the issue-intake capability. */
+export declare const INTAKE_TRIGGER_CAPABILITY_LABEL = "Consider incoming issues \u2192 task/prd + surface the review verdict into the issue thread (the intake trigger: issues / issue_comment / label)";
+/** The repo-relative path (under the output base) of the emitted workflow. */
+export declare const INTAKE_TRIGGER_WORKFLOW_PATH = "workflows/intake.yml";
+/**
+ * The intake-trigger LABEL: a label whose addition (re-)triggers intake on an
+ * issue (the "label" trigger of capability D), brand-namespaced exactly like the
+ * `processing` lock so it cannot collide with a user's own labels. DISTINCT from
+ * the transient `processing` lock — this one is a human-facing "please (re-)intake
+ * this" signal, not a concurrency mutex.
+ */
+export declare const INTAKE_TRIGGER_LABEL: string;
+/**
+ * The trusted `author_association` values (Decision 1): a repo OWNER, an org
+ * MEMBER, or a write-COLLABORATOR is TRUSTED; everyone else
+ * (`CONTRIBUTOR`/`FIRST_TIME_CONTRIBUTOR`/`FIRST_TIMER`/`NONE`/anything unknown)
+ * is UNTRUSTED. This is the WHOLE author-trust signal — admin/write-collaborator,
+ * read straight off the event payload, no extra API call, no multi-factor matrix.
+ */
+export declare const TRUSTED_AUTHOR_ASSOCIATIONS: readonly ["OWNER", "MEMBER", "COLLABORATOR"];
+/**
+ * The per-outcome integration flags CI passes to `intake <N>` — the GRANULAR
+ * per-type pair (the aggregates `--merge`/`--propose` are not needed because CI
+ * always resolves BOTH types explicitly). Each is `'merge'` or `'propose'`.
+ */
+export interface IntakeIntegrationFlags {
+    /** The spec outcome's mode → `--merge-spec` / `--propose-spec`. */
+    spec: 'merge' | 'propose';
+    /** The task outcome's mode → `--merge-task` / `--propose-task`. */
+    task: 'merge' | 'propose';
+    /**
+     * The ORIGIN-TRUST verdict CI passes to `intake <N>` via `--origin-trust`
+     * (task `untrusted-origin-forces-build-propose`) so the emitted prd/task is
+     * STAMPED with how it was born. Derived from the SAME `author_association` case
+     * as the integration flags (it IS `authorTrusted` collapsed to the wire value),
+     * so the stamp and the integration mode CANNOT desync. `intake.ts` writes it
+     * verbatim onto the frontmatter — it never re-resolves trust (the `intake.ts`
+     * ~L296 boundary: author-trust is CI's POLICY, passed IN, not resolved here).
+     */
+    originTrust: 'trusted' | 'untrusted';
+}
+/** The gate state CI composes with author-trust to derive the per-outcome flags. */
+export interface IntakeGateState {
+    /**
+     * `autoBuild` — whether an agent will AUTO-BUILD an undeclared task next. ON ⇒
+     * a task needs a human PR checkpoint NOW (`--propose-task`); OFF ⇒ a human
+     * must build it, so it may `--merge-task` (when the author is also trusted).
+     */
+    autoBuild: boolean;
+    /**
+     * `autoTask` — whether an agent will AUTO-TASK an undeclared spec next. ON ⇒ a
+     * spec needs a human PR checkpoint NOW (`--propose-spec`); OFF ⇒ a human must
+     * task it, so it may `--merge-spec`.
+     */
+    autoTask: boolean;
+}
+/**
+ * DERIVE the per-outcome merge-vs-propose flags from the gate state COMPOSED with
+ * author-trust — CI's merge-vs-propose POLICY (prd "merge-vs-propose POLICY" +
+ * "Composed with AUTHOR-TRUST"; task Decision 1). This is the load-bearing pure
+ * logic the workflow encodes at runtime (it reads `author_association` off the
+ * event payload and sets the flags accordingly):
+ *
+ *   - **SPEC** — gate-derived ONLY (author-trust does NOT bite): `--merge-spec` iff
+ *     `autoTask` is OFF (a human must task the spec before anything autonomous
+ *     acts on it — the human checkpoint stays AHEAD even for an untrusted author),
+ *     else `--propose-spec`.
+ *   - **TASK** — `--propose-task` iff (`autoBuild` ON) OR (author UNTRUSTED);
+ *     `--merge-task` ONLY iff (`autoBuild` OFF AND author TRUSTED). An untrusted
+ *     author can never auto-merge a task from a public-front-door issue.
+ *
+ * So the only way to `--merge-task` is a TRUSTED author with `autoBuild` OFF —
+ * and the fully-gateless "merge everything" path additionally needs `autoTask`
+ * OFF; both gates off + a trusted author is the LOUD, NON-DEFAULT opt-in. The
+ * conservative case (untrusted author, or any gate on) keeps a human in the loop.
+ */
+export declare function deriveIntakeFlags(options: {
+    gate: IntakeGateState;
+    authorTrusted: boolean;
+}): IntakeIntegrationFlags;
+/**
+ * Classify an `author_association` string into trusted/untrusted (Decision 1). A
+ * missing/empty/unknown value is UNTRUSTED (fail-safe: a public front-door defaults
+ * to the conservative, human-in-the-loop path). Case-insensitive on the wire value
+ * for robustness, though GitHub emits upper-case.
+ */
+export declare function isAuthorTrusted(authorAssociation: string | undefined): boolean;
+/**
+ * Generate the intake-trigger workflow YAML. Deterministic: the same config
+ * produces byte-identical output. The workflow is a FIXED shell (ADR §6: all
+ * policy is env/config, so the artifact carries no config-derived policy beyond
+ * the env-block scaffolding) — `config` is accepted for parity with the
+ * `CapabilityEmitter` seam and future per-config wiring, but the intake-trigger
+ * shape itself is config-independent.
+ *
+ * The per-outcome FLAGS are DERIVED AT RUNTIME by a `bash` step that mirrors
+ * {@link deriveIntakeFlags}: it reads the gate env block + the event's
+ * `author_association` and sets `--merge-spec`/`--propose-spec` +
+ * `--merge-task`/`--propose-task` accordingly. The same rule that
+ * {@link deriveIntakeFlags} unit-tests is what the workflow executes — they cannot
+ * desync because the test asserts the SHELL derivation matches the function.
+ */
+export declare function generateIntakeWorkflow(config: ResolvedCIConfig): string;
+/** A single structural problem found in the generated workflow. */
+export interface IntakeTriggerProblem {
+    /** A short, stable id for the violated invariant (for tests/assertions). */
+    id: string;
+    /** Human-readable description of what is missing or wrong. */
+    message: string;
+}
+/** The result of {@link validateIntakeWorkflow}. */
+export interface IntakeTriggerValidation {
+    /** True iff the workflow satisfies EVERY structural invariant. */
+    ok: boolean;
+    /** Each violated invariant (empty when `ok`). */
+    problems: IntakeTriggerProblem[];
+}
+/**
+ * Structurally validate the intake-trigger workflow against the task's acceptance
+ * criteria. Dependency-free (no YAML lib): presence/shape assertions over the raw
+ * text, mirroring {@link validateAdvanceLifecycleWorkflow} /
+ * {@link validateCloseJobWorkflow}.
+ */
+export declare function validateIntakeWorkflow(text: string): IntakeTriggerValidation;
+//# sourceMappingURL=intake-trigger-template.d.ts.map

package/dist/intake-trigger-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intake-trigger-template.d.ts","sourceRoot":"","sources":["../src/intake-trigger-template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAGH,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAG3D,6EAA6E;AAC7E,eAAO,MAAM,4BAA4B,WAAW,CAAC;AAErD,+DAA+D;AAC/D,eAAO,MAAM,+BAA+B,qJACkG,CAAC;AAE/I,8EAA8E;AAC9E,eAAO,MAAM,4BAA4B,yBAAyB,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,QAAyB,CAAC;AAI3D;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,8CAI9B,CAAC;AAEX;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACtC,mEAAmE;IACnE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B,mEAAmE;IACnE,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;IAC1B;;;;;;;;OAQG;IACH,WAAW,EAAE,SAAS,GAAG,WAAW,CAAC;CACrC;AAED,oFAAoF;AACpF,MAAM,WAAW,eAAe;IAC/B;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IAC1C,IAAI,EAAE,eAAe,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;CACvB,GAAG,sBAAsB,CAoBzB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACnC,OAAO,CAMT;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CA4LvE;AAED,mEAAmE;AACnE,MAAM,WAAW,oBAAoB;IACpC,4EAA4E;IAC5E,EAAE,EAAE,MAAM,CAAC;IACX,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,oDAAoD;AACpD,MAAM,WAAW,uBAAuB;IACvC,kEAAkE;IAClE,EAAE,EAAE,OAAO,CAAC;IACZ,iDAAiD;IACjD,QAAQ,EAAE,oBAAoB,EAAE,CAAC;CACjC;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB,CAsK5E"}