@jitsusama/agentic-harness.core 0.1.0

package/dist/review/retarget.js

@@ -0,0 +1,82 @@
+/**
+ * Pointing a stack's changes back at what they now sit on.
+ *
+ * A local restack moves branches. It does not touch the changes those
+ * branches are proposed as, so afterwards each one still claims to
+ * merge into whatever it targeted when it went up. On a stack whose
+ * bottom has landed, that is a change targeting a branch nobody is
+ * merging any more, and the diff it shows is against the wrong thing.
+ *
+ * Whose job it is to fix that differs by backend, which is what
+ * deferred this the first time. On one, retargeting is per change and
+ * the caller walks the stack doing it. On another it is a single stack
+ * operation, because the backend holds the stack itself and moving one
+ * change without the others would leave its own model inconsistent.
+ *
+ * So the substrate does what it does for a diff: implement the general
+ * case over the parts every provider has, and stand aside where a
+ * provider says it owns the whole operation. The generic walk is not a
+ * lesser version of the native one; for a backend that has no notion
+ * of a stack it is the only version there is, and it is right there.
+ */
+/**
+ * Which changes in a stack point at the wrong base, and where they go.
+ *
+ * Roots are excluded rather than pointed at the trunk. A root already
+ * targets the trunk in the ordinary case, and where it does not, the
+ * stack cannot say whether that is wrong: somebody may be proposing a
+ * root against a release branch on purpose, and moving it to the trunk
+ * would retarget a change nobody asked about onto a branch that asks a
+ * different team to review it.
+ */
+export function retargetPlan(stack) {
+    const moves = [];
+    const skipped = [];
+    for (const node of stack.nodes) {
+        if (node.proposal === undefined) {
+            // Nothing to retarget. A branch with no change on it is a
+            // perfectly ordinary part of a stack somebody has not put up
+            // yet, so this is a fact rather than a problem.
+            skipped.push({ ref: node.ref, why: "nothing is proposed on it" });
+            continue;
+        }
+        if (node.parent === undefined) {
+            skipped.push({
+                ref: node.ref,
+                why: "it is a root, so what it targets is not the stack's to decide",
+            });
+            continue;
+        }
+        const now = node.proposal.base;
+        if (now === node.parent)
+            continue;
+        moves.push({ ref: node.ref, from: now, to: node.parent });
+    }
+    return { moves, skipped };
+}
+/**
+ * Who should carry out a retarget, and why that is the right answer.
+ *
+ * Named rather than decided silently because the two fail differently
+ * and a caller has to be able to report which happened. A native pass
+ * either moves the stack or does not. A per-change walk can stop half
+ * way, leaving some changes moved and some not, and somebody reading
+ * "retarget failed" needs to know which of those they are looking at.
+ */
+export function retargetRoute(stacking, authoring) {
+    if (stacking?.restack !== undefined) {
+        return {
+            kind: "native",
+            why: "this backend holds the stack itself, so it moves as one",
+        };
+    }
+    if (authoring?.edit !== undefined) {
+        return {
+            kind: "per-change",
+            why: "this backend has no stack operation, so each change is moved in turn",
+        };
+    }
+    return {
+        refusal: "This backend can neither restack nor edit a change's base, so there is no way to retarget from here. Move the changes wherever they are hosted.",
+    };
+}

package/dist/review/revisited.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Whether you have reviewed this before, and whether it has moved since.
+ *
+ * Re-reviewing a change means reading the whole diff again and hoping to notice
+ * which parts are new. That is the wrong job for a person: the backend knows
+ * which commit was on top when the review was posted, and nothing was recording
+ * it.
+ *
+ * So it is recorded, per change, when a review is published. What that buys is
+ * modest and worth being precise about. It says whether the change has moved
+ * since you last looked, which is the difference between re-reading a diff and
+ * knowing you do not have to. It does not say what changed: a diff between two
+ * commits needs the commits, which means a local tree, and a backend that
+ * publishes no fetchable ref cannot supply one. Where that is possible the
+ * caller can go and take the diff itself; where it is not, knowing the change
+ * has moved is still the answer to the question people actually ask.
+ *
+ * The store is deliberately dumb. It is a record of what happened, not a cache:
+ * nothing here is derived, so nothing here can go stale in a way that lies.
+ */
+import type { ChangeRef, Proposal } from "./change.js";
+/** A review you posted, and the change as it stood then. */
+export interface Visit {
+    /** The change, keyed the way every other store here keys one. */
+    key: string;
+    /** The tip commit when the review was posted, when the backend said. */
+    commit?: string;
+    /** When, as an ISO instant. */
+    at: string;
+    /** What the review said as a whole, for a listing. */
+    verdict?: string;
+}
+/** Where a change stands relative to the last time you reviewed it. */
+export type SinceLastVisit = {
+    kind: "never";
+} | {
+    kind: "unmoved";
+    visit: Visit;
+} | {
+    kind: "moved";
+    visit: Visit;
+    /** The tip now. */
+    commit: string;
+} | {
+    kind: "cannot-tell";
+    visit: Visit;
+    /** Why, in words. */
+    because: string;
+};
+/** Recording and reading the reviews you have posted. */
+export interface VisitLog {
+    record(ref: ChangeRef, visit: Omit<Visit, "key">): Visit;
+    /** The most recent visit to this change, if any. */
+    last(ref: ChangeRef): Visit | undefined;
+    /** Every visit, newest first. */
+    all(): readonly Visit[];
+}
+/**
+ * A log of reviews posted, kept as one file per change.
+ *
+ * One file per change rather than one file for everything, for the same reason
+ * the attachment store is: two sessions reviewing two changes at once write to
+ * two files and neither has to merge the other's.
+ */
+export declare function createVisitLog(dir: string): VisitLog;
+/**
+ * What has happened to a change since you last reviewed it.
+ *
+ * Four answers rather than a boolean, because a caller acts differently on each
+ * and collapsing them loses the distinction that matters. Never reviewed is not
+ * the same as reviewed and unchanged, and neither is the same as a backend that
+ * will not say which commit is on top: that last one has to read as its own
+ * answer, or a change that moved silently looks like one that did not move.
+ */
+export declare function sinceLastVisit(visit: Visit | undefined, proposal: Proposal): SinceLastVisit;
+/** Said in words, for a listing. */
+export declare function describeVisit(said: SinceLastVisit): string;

package/dist/review/revisited.js

@@ -0,0 +1,121 @@
+/**
+ * Whether you have reviewed this before, and whether it has moved since.
+ *
+ * Re-reviewing a change means reading the whole diff again and hoping to notice
+ * which parts are new. That is the wrong job for a person: the backend knows
+ * which commit was on top when the review was posted, and nothing was recording
+ * it.
+ *
+ * So it is recorded, per change, when a review is published. What that buys is
+ * modest and worth being precise about. It says whether the change has moved
+ * since you last looked, which is the difference between re-reading a diff and
+ * knowing you do not have to. It does not say what changed: a diff between two
+ * commits needs the commits, which means a local tree, and a backend that
+ * publishes no fetchable ref cannot supply one. Where that is possible the
+ * caller can go and take the diff itself; where it is not, knowing the change
+ * has moved is still the answer to the question people actually ask.
+ *
+ * The store is deliberately dumb. It is a record of what happened, not a cache:
+ * nothing here is derived, so nothing here can go stale in a way that lies.
+ */
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { changeKey } from "./keys.js";
+/** A file name that cannot collide or escape its directory. */
+function fileFor(key) {
+    return `${key.replace(/[^a-zA-Z0-9._-]+/g, "-")}.json`;
+}
+/**
+ * A log of reviews posted, kept as one file per change.
+ *
+ * One file per change rather than one file for everything, for the same reason
+ * the attachment store is: two sessions reviewing two changes at once write to
+ * two files and neither has to merge the other's.
+ */
+export function createVisitLog(dir) {
+    function read() {
+        let names;
+        try {
+            names = readdirSync(dir).filter((name) => name.endsWith(".json"));
+        }
+        catch {
+            // No directory yet means nothing has been reviewed, which is a
+            // state and not a failure.
+            return [];
+        }
+        const found = [];
+        for (const name of names) {
+            try {
+                const held = JSON.parse(readFileSync(join(dir, name), "utf8"));
+                if (typeof held === "object" &&
+                    held !== null &&
+                    typeof held.key === "string" &&
+                    typeof held.at === "string") {
+                    found.push(held);
+                }
+            }
+            catch {
+                // A half-written or hand-edited file is skipped rather than
+                // bringing down every other answer with it.
+            }
+        }
+        return found.sort((one, other) => other.at.localeCompare(one.at));
+    }
+    return {
+        record(ref, visit) {
+            const key = changeKey(ref);
+            const held = { ...visit, key };
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, fileFor(key)), JSON.stringify(held, null, 2));
+            return held;
+        },
+        last(ref) {
+            const key = changeKey(ref);
+            return read().find((visit) => visit.key === key);
+        },
+        all: read,
+    };
+}
+/**
+ * What has happened to a change since you last reviewed it.
+ *
+ * Four answers rather than a boolean, because a caller acts differently on each
+ * and collapsing them loses the distinction that matters. Never reviewed is not
+ * the same as reviewed and unchanged, and neither is the same as a backend that
+ * will not say which commit is on top: that last one has to read as its own
+ * answer, or a change that moved silently looks like one that did not move.
+ */
+export function sinceLastVisit(visit, proposal) {
+    if (visit === undefined)
+        return { kind: "never" };
+    if (visit.commit === undefined) {
+        return {
+            kind: "cannot-tell",
+            visit,
+            because: "the tip commit was not recorded when you reviewed, so there is nothing to compare against",
+        };
+    }
+    if (proposal.headCommit === undefined) {
+        return {
+            kind: "cannot-tell",
+            visit,
+            because: "this backend does not report which commit is on top",
+        };
+    }
+    if (proposal.headCommit === visit.commit)
+        return { kind: "unmoved", visit };
+    return { kind: "moved", visit, commit: proposal.headCommit };
+}
+/** Said in words, for a listing. */
+export function describeVisit(said) {
+    switch (said.kind) {
+        case "never":
+            return "You have not reviewed this before.";
+        case "unmoved":
+            return `You reviewed this on ${said.visit.at.slice(0, 10)} and it has not moved since.`;
+        case "moved":
+            return `You reviewed this on ${said.visit.at.slice(0, 10)} at ${said.visit.commit?.slice(0, 12)}. It is now at ${said.commit.slice(0, 12)}, so there is new work to read.`;
+        case "cannot-tell":
+            return `You reviewed this on ${said.visit.at.slice(0, 10)}, but ${said.because}.`;
+    }
+}

package/dist/review/stack.d.ts

@@ -0,0 +1,110 @@
+/**
+ * A stack: refs pointing at refs.
+ *
+ * Topology comes first and proposals decorate it, which is
+ * the inverse of deriving a stack from a list of pull
+ * requests. The inversion matters because a stack of
+ * branches nobody has proposed yet is still a stack, and
+ * because the one backend that projects stacks server-side
+ * hands back topology whether or not every node has a
+ * proposal on it.
+ *
+ * Every stack says where its shape came from. One backend
+ * knows the answer, one has to guess from base and head
+ * names, and a bare repo reads it out of local config. A
+ * consumer that cannot tell those apart will present a
+ * guess as fact.
+ */
+import type { Proposal } from "./change.js";
+/**
+ * Where a stack's shape came from. `authoritative` means the
+ * backend recorded the parentage; `derived` means it was
+ * inferred and may be wrong at the edges.
+ */
+export type StackProvenance = "authoritative" | "derived";
+/** One ref in a stack. */
+export interface StackNode {
+    /** The ref this node is, e.g. `refs/heads/topic`. */
+    ref: string;
+    /** The ref it sits on, absent for the root. */
+    parent?: string;
+    /** Tip commit of `ref`, when known. */
+    headCommit?: string;
+    /**
+     * Commit where this node left its parent, when known.
+     * Every local stacking tool surveyed records this, since
+     * it is what makes a restack possible after a rebase.
+     */
+    forkPoint?: string;
+    /** The proposal on this node, when one exists. */
+    proposal?: Proposal;
+    /**
+     * True when the parent has moved since this node last
+     * agreed with it, where the provider can tell.
+     */
+    behindParent?: boolean;
+}
+/** A stack, rooted at a trunk. */
+export interface Stack {
+    provenance: StackProvenance;
+    /**
+     * The trunk the stack ultimately targets, when known.
+     * Not a node: the trunk is not part of the stack.
+     */
+    trunk?: string;
+    /**
+     * Nodes in topological order, roots before children. A
+     * stack may fan out, so this is a tree flattened rather
+     * than a chain.
+     */
+    nodes: StackNode[];
+    /**
+     * Index in `nodes` of the ref the caller is standing on,
+     * when the question has an answer.
+     */
+    cursor?: number;
+}
+/**
+ * Where one step through a stack lands.
+ *
+ * Four outcomes rather than a node or nothing, because each one
+ * needs saying differently. Standing at the tip is not a failure,
+ * a node that fans out has no single answer, and a stack that
+ * does not mention the ref at all is a partial answer from the
+ * provider rather than a wrong question.
+ */
+export type StackStep = 
+/** One place to go, so go there. */
+{
+    kind: "move";
+    node: StackNode;
+}
+/** Several children, so the caller has to choose. */
+ | {
+    kind: "choose";
+    candidates: StackNode[];
+}
+/** Nothing that way: the tip going up, the trunk going down. */
+ | {
+    kind: "edge";
+    at: "tip" | "root";
+}
+/** This stack does not place the ref at all. */
+ | {
+    kind: "unplaced";
+};
+/**
+ * Step through a stack from the ref you are standing on.
+ *
+ * Going up is the interesting direction, because a stack is a
+ * tree flattened rather than a chain, so a node can have several
+ * children. Picking one would land the reader on a sibling branch
+ * without saying so, which is the same mistake as guessing
+ * between attached changes, and it gets the same answer: report
+ * the candidates and let them choose.
+ *
+ * Going down is always unambiguous, since a node has one parent.
+ * A parent the stack does not contain means the parent is the
+ * trunk, and the trunk is deliberately not a node.
+ */
+export declare function stackStep(stack: Stack, fromRef: string, direction: "next" | "prev"): StackStep;

package/dist/review/stack.js

@@ -0,0 +1,52 @@
+/**
+ * A stack: refs pointing at refs.
+ *
+ * Topology comes first and proposals decorate it, which is
+ * the inverse of deriving a stack from a list of pull
+ * requests. The inversion matters because a stack of
+ * branches nobody has proposed yet is still a stack, and
+ * because the one backend that projects stacks server-side
+ * hands back topology whether or not every node has a
+ * proposal on it.
+ *
+ * Every stack says where its shape came from. One backend
+ * knows the answer, one has to guess from base and head
+ * names, and a bare repo reads it out of local config. A
+ * consumer that cannot tell those apart will present a
+ * guess as fact.
+ */
+/**
+ * Step through a stack from the ref you are standing on.
+ *
+ * Going up is the interesting direction, because a stack is a
+ * tree flattened rather than a chain, so a node can have several
+ * children. Picking one would land the reader on a sibling branch
+ * without saying so, which is the same mistake as guessing
+ * between attached changes, and it gets the same answer: report
+ * the candidates and let them choose.
+ *
+ * Going down is always unambiguous, since a node has one parent.
+ * A parent the stack does not contain means the parent is the
+ * trunk, and the trunk is deliberately not a node.
+ */
+export function stackStep(stack, fromRef, direction) {
+    const standing = stack.nodes.find((n) => n.ref === fromRef);
+    if (!standing)
+        return { kind: "unplaced" };
+    if (direction === "next") {
+        const children = stack.nodes.filter((n) => n.parent === fromRef);
+        if (children.length === 0)
+            return { kind: "edge", at: "tip" };
+        const only = children[0];
+        if (children.length === 1 && only !== undefined) {
+            return { kind: "move", node: only };
+        }
+        return { kind: "choose", candidates: children };
+    }
+    const parent = standing.parent === undefined
+        ? undefined
+        : stack.nodes.find((n) => n.ref === standing.parent);
+    return parent === undefined
+        ? { kind: "edge", at: "root" }
+        : { kind: "move", node: parent };
+}

package/dist/sections/block.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Turns detected section violations into a single skill-grounded
+ * instruction the guardian hands back to the author. The message
+ * names every invented and missing heading and points at the
+ * format skill so the retry is informed, not a guess.
+ */
+import type { SectionViolation } from "./detect.js";
+/** Format section violations into a block message, or "" if none. */
+export declare function formatSectionBlock(violations: SectionViolation[], entityLabel: string, skill: string): string;

package/dist/sections/block.js

@@ -0,0 +1,42 @@
+/**
+ * Turns detected section violations into a single skill-grounded
+ * instruction the guardian hands back to the author. The message
+ * names every invented and missing heading and points at the
+ * format skill so the retry is informed, not a guess.
+ */
+/** Format section violations into a block message, or "" if none. */
+export function formatSectionBlock(violations, entityLabel, skill) {
+    if (violations.length === 0)
+        return "";
+    const invented = violations.filter((v) => v.issue === "invented");
+    const missing = violations.filter((v) => v.issue === "missing");
+    const misordered = violations.filter((v) => v.issue === "misordered");
+    const lines = [
+        `This ${entityLabel} body does not use the sections the`,
+        `${skill} skill defines. The section set is closed: use exactly`,
+        "those headings, written exactly as the skill shows them (the",
+        "emoji, the name and the heading level together). Fix the body",
+        "and try again.",
+        "",
+    ];
+    if (invented.length > 0) {
+        lines.push("Headings that are not part of the set, remove or rename them:");
+        for (const v of invented)
+            lines.push(`  ${v.found}`);
+        lines.push("");
+    }
+    if (missing.length > 0) {
+        lines.push("Required headings the body is missing, add them:");
+        for (const v of missing)
+            lines.push(`  ${v.found}`);
+        lines.push("");
+    }
+    if (misordered.length > 0) {
+        lines.push("The sections are out of order; put them in this order:");
+        for (const v of misordered)
+            lines.push(`  ${v.found}`);
+        lines.push("");
+    }
+    lines.push(`See the ${skill} skill for what belongs in each section.`);
+    return lines.join("\n");
+}

package/dist/sections/detect.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Section convention detection: finds headings in a PR or issue
+ * body that are not in the sanctioned set (invented) and
+ * sanctioned headings that the body omits (missing). The
+ * sanctioned set is a closed list of exact heading strings,
+ * including the heading level and the emoji, so a sanctioned
+ * name at the wrong level or with a swapped emoji reads as
+ * invented. Detection never rewrites; it names the offending or
+ * absent headings and leaves the repair to the author.
+ */
+import type { Violation } from "../gate/index.js";
+/** A single section convention violation. */
+export interface SectionViolation extends Violation {
+    readonly kind: "section";
+    /**
+     * invented: a heading not in the set. missing: a required
+     * heading absent. misordered: the present sanctioned headings
+     * are not in the order the skill mandates.
+     */
+    readonly issue: "invented" | "missing" | "misordered";
+    /**
+     * The offending heading (invented), the absent one (missing) or
+     * the required order of the present headings (misordered).
+     */
+    readonly found: string;
+}
+/**
+ * Find every heading in a body that is not sanctioned (invented)
+ * and every sanctioned heading the body omits (missing).
+ */
+export declare function detectSectionViolations(body: string, sanctioned: readonly string[]): SectionViolation[];

package/dist/sections/detect.js

@@ -0,0 +1,67 @@
+/**
+ * Section convention detection: finds headings in a PR or issue
+ * body that are not in the sanctioned set (invented) and
+ * sanctioned headings that the body omits (missing). The
+ * sanctioned set is a closed list of exact heading strings,
+ * including the heading level and the emoji, so a sanctioned
+ * name at the wrong level or with a swapped emoji reads as
+ * invented. Detection never rewrites; it names the offending or
+ * absent headings and leaves the repair to the author.
+ */
+const FENCE_REGEX = /```[\s\S]*?```/g;
+const HEADING_REGEX = /^(#{1,6})[ \t]+(.+?)[ \t]*$/gm;
+// Emoji presentation selector. The check mark renders with or
+// without it depending on the editor; normalize it away so
+// `✅` and `✅️` compare equal against the sanctioned set.
+const VARIATION_SELECTOR = /️/g;
+/** Canonicalize a heading to `<hashes> <text>` with single spacing. */
+function canonical(hashes, text) {
+    return `${hashes} ${text}`.replace(VARIATION_SELECTOR, "");
+}
+/** Mask fenced code blocks so a `#` inside them is never a heading. */
+function maskFences(body) {
+    return body.replace(FENCE_REGEX, (match) => " ".repeat(match.length));
+}
+/**
+ * Find every heading in a body that is not sanctioned (invented)
+ * and every sanctioned heading the body omits (missing).
+ */
+export function detectSectionViolations(body, sanctioned) {
+    const sanctionedSet = new Set(sanctioned.map((h) => h.replace(VARIATION_SELECTOR, "")));
+    const masked = maskFences(body);
+    const present = new Set();
+    // The sanctioned headings in the order they first appear, so a
+    // reordering can be compared against the canonical sequence.
+    const presentInOrder = [];
+    const violations = [];
+    for (const match of masked.matchAll(HEADING_REGEX)) {
+        const heading = canonical(match[1], match[2]);
+        if (sanctionedSet.has(heading)) {
+            if (!present.has(heading))
+                presentInOrder.push(heading);
+            present.add(heading);
+        }
+        else {
+            violations.push({ kind: "section", issue: "invented", found: heading });
+        }
+    }
+    for (const heading of sanctionedSet) {
+        if (!present.has(heading)) {
+            violations.push({ kind: "section", issue: "missing", found: heading });
+        }
+    }
+    // The skill mandates a fixed order. Compare the present
+    // headings against their canonical sequence; if they differ,
+    // the body is out of order even when the set is complete.
+    const canonicalOrder = sanctioned
+        .map((h) => h.replace(VARIATION_SELECTOR, ""))
+        .filter((h) => present.has(h));
+    if (presentInOrder.join("\n") !== canonicalOrder.join("\n")) {
+        violations.push({
+            kind: "section",
+            issue: "misordered",
+            found: canonicalOrder.join(" then "),
+        });
+    }
+    return violations;
+}

package/dist/sections/gate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The section gate: a thin adapter over the shared loop breaker
+ * in the gate module. It supplies the section-specific detection,
+ * block formatting and relent wording; the block-first,
+ * relent-on-repeat mechanism lives in decideGate so prose and
+ * sections share one behaviour.
+ */
+import { type GateDecision } from "../gate/index.js";
+/** What the gate needs to know about the artifact under review. */
+export interface SectionGateConfig {
+    /** The closed set of sanctioned headings for this artifact. */
+    readonly sanctioned: readonly string[];
+    /** "PR" or "issue", for the block message. */
+    readonly entityLabel: string;
+    /** The format skill that owns the section set, for the message. */
+    readonly skill: string;
+}
+/** The gate's verdict on one body's sections. */
+export type SectionGateDecision = GateDecision;
+/** Decide whether to block, relent or allow given prior block signatures. */
+export declare function sectionGateDecision(body: string, priorSignatures: string[], config: SectionGateConfig): SectionGateDecision;

package/dist/sections/gate.js

@@ -0,0 +1,22 @@
+/**
+ * The section gate: a thin adapter over the shared loop breaker
+ * in the gate module. It supplies the section-specific detection,
+ * block formatting and relent wording; the block-first,
+ * relent-on-repeat mechanism lives in decideGate so prose and
+ * sections share one behaviour.
+ */
+import { decideGate } from "../gate/index.js";
+import { formatSectionBlock } from "./block.js";
+import { detectSectionViolations } from "./detect.js";
+/** Decide whether to block, relent or allow given prior block signatures. */
+export function sectionGateDecision(body, priorSignatures, config) {
+    const violations = detectSectionViolations(body, config.sanctioned);
+    const relentPrefix = [
+        `This ${config.entityLabel} body still breaks the ${config.skill}`,
+        "section set after a previous attempt, so it is being let through",
+        "rather than blocked again. Review the remaining section problems",
+        "yourself:",
+        "",
+    ].join("\n");
+    return decideGate(violations, priorSignatures, (v) => formatSectionBlock(v, config.entityLabel, config.skill), relentPrefix, body);
+}

package/dist/sections/index.d.ts

@@ -0,0 +1,5 @@
+export { violationSignature } from "../gate/index.js";
+export { formatSectionBlock } from "./block.js";
+export { detectSectionViolations, type SectionViolation, } from "./detect.js";
+export { type SectionGateConfig, type SectionGateDecision, sectionGateDecision, } from "./gate.js";
+export { ISSUE_SECTIONS, PR_SECTIONS } from "./sanctioned.js";

package/dist/sections/index.js

@@ -0,0 +1,5 @@
+export { violationSignature } from "../gate/index.js";
+export { formatSectionBlock } from "./block.js";
+export { detectSectionViolations, } from "./detect.js";
+export { sectionGateDecision, } from "./gate.js";
+export { ISSUE_SECTIONS, PR_SECTIONS } from "./sanctioned.js";

package/dist/sections/sanctioned.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The closed set of sanctioned section headings, one set per
+ * artifact. Each entry is the exact heading string the body must
+ * use: the hashes, the emoji and the name together.
+ *
+ * These constants are the single source the gate enforces, but
+ * the skills are the single source of truth for what the
+ * conventions are.
+ */
+/** The PR body's three required sections, in order. */
+export declare const PR_SECTIONS: readonly ["### 🌐 Situation", "### 🔧 Resolution", "### 🔬 Validation"];
+/** The issue body's three required sections, in order. */
+export declare const ISSUE_SECTIONS: readonly ["### 🌐 Situation", "### 🎯 Outcome", "### ✅ Acceptance"];