bareloop 0.9.0 → 0.11.0

package/types/authoring.d.ts

@@ -102,6 +102,60 @@ export function genreEnv(lang: string, { sourcePrefixes }?: {
  * one of them, because ownership is only real if it is mechanical.
  * @param {string} lang @returns {string[]} */
 export function genreOwnedEnvNames(lang: string): string[];
+/**
+ * HOW THE GENRE'S OWN TOOLS PRINT — genre property, like the suppression battery
+ * and like `MYPYPATH`, and for the same reason: it is a FACT ABOUT AN INSTRUMENT
+ * WE ALREADY OWN, not a composition choice. Seven hand-written closes read tsc
+ * with the identical `/error TS\d+/` (`scripts/u-pulselog-close.mjs:122`,
+ * `u-bareguard-close.mjs:123`, `u-bareagent-close.mjs:123`,
+ * `u-baremobile-close.mjs:122`, `u-litectx-close.mjs:140`, `types-close.mjs:190`,
+ * `types-check.mjs:60`) and one reads mypy with `' error: '`
+ * (`u-spawner-close.mjs:133`) — the same provenance the SUPPRESSIONS table has:
+ * operator knowledge minted by paying for live runs.
+ *
+ * WHY IT BECAME GENRE DATA (run msmbpjk6, 2026-08-09, $0.43). Left to the model,
+ * the parser for a known tool is a DRAFT-TIME LOTTERY on a fact nobody needed to
+ * guess: that run composed tsc's TTY-only pretty shape
+ * (`^\S+\.js:\d+:\d+ - error TS\d+:`), which matched 0 of the 67 real error lines
+ * the piped run actually printed, while the tool exited 2. The gates held — the
+ * stage read as a crashed instrument and signing was refused, correctly — but the
+ * refusal cost a whole authoring run to learn something the tree already knew. An
+ * earlier run (mslwbkz7) happened to roll the right shape. A coin-flip on an
+ * owned fact is not a capability question.
+ *
+ * WHAT THIS IS NOT: it does not close the parser. A stage counting something we
+ * have NOT measured still writes its own pattern, and that remains a real gap —
+ * named, not smoothed. This table is where a measured instrument fact lands, one
+ * at a time, with its provenance.
+ *
+ * THE TEST-COUNT FACTS (2026-08-13) landed under exactly that rule, and closed
+ * two of the three gaps the paragraph above used to name by hand: the executed
+ * count and the failure line, for both runners, are now measured facts rather
+ * than draft-time lotteries. Provenance rides on each entry.
+ *
+ * WHAT STAYED OUT, deliberately, because no evidence covers it:
+ *  - a pytest FAIL-COUNT figure. A green pytest run omits the segment entirely
+ *    (`1 passed in 0.04s`), so a figure term over it reports "never reported" on
+ *    precisely the runs that went well. Failures are counted with the `^FAILED `
+ *    tally instead, where no match IS zero.
+ *  - a pytest EXECUTED count. `collected N items` is printed under `-ra` and NOT
+ *    under `-q` (measured both ways), so no single spelling survives the modes a
+ *    patient may configure; a stage needing it still composes its own and says so.
+ *
+ * Returns a fresh copy per call, for the reason `classGuards` does: a frozen
+ * constant handed to a caller that edits it is one shared table away from a
+ * silently changed ruler.
+ * @param {string} lang
+ * @returns {{id: string, what: string, lineMatch: string, capture: number|null, example: string, why: string}[]}
+ */
+export function genreInstruments(lang: string): {
+    id: string;
+    what: string;
+    lineMatch: string;
+    capture: number | null;
+    example: string;
+    why: string;
+}[];
 /**
  * GROUNDING for a RECORDED genre environment — the provenance half of the
  * owned-env rule, and the reason the by-value comparison is worth anything.
@@ -236,9 +290,11 @@ export function normalizeDeclaration(declaration: any): any;
 /** @typedef {{required: readonly string[], optional: readonly string[], pathParams: readonly string[], locked?: true, verdictClass: string, shape: string, asserts: string}} KindSpec */
 /** the whole menu, in ascending order of what it takes to render the verdict */
 export const VERDICT_CLASSES: readonly string[];
-/** declared-but-locked: selecting one is COUNTED demand, never an admission */
+/** declared-but-locked: selecting one is COUNTED demand, never an admission.
+ * `hitl` LEFT this list at N4 slice 1 (see `src/job.js`'s twin) — the class is
+ * built, and its battery is below. `soft-green` waits for the judged floor. */
 export const LOCKED_CLASSES: readonly string[];
-/** the classes v1 actually builds — exactly one */
+/** the classes v1 actually builds */
 export const LIVE_CLASSES: readonly string[];
 /**
  * The whole vocabulary, as DATA. `shape` and `asserts` are the strings the
@@ -368,6 +424,42 @@ export const TYPES_GENRE: Readonly<{
             /** no import-resolution hazard on this runner — an EMPTY list, declared,
              * never an absent field that would read as "not looked into" (F59) */
             env: readonly never[];
+            instruments: readonly (Readonly<{
+                id: "tsc-error-line";
+                what: "one type error, as the TypeScript checker prints it";
+                lineMatch: "error TS\\d+";
+                capture: null;
+                example: "src/backup.js(21,19): error TS7006: Parameter 'now' implicitly has an 'any' type.";
+                why: string;
+            }> | Readonly<{
+                id: "node-test-total-count";
+                what: "how many tests the runner EXECUTED, off the TAP summary";
+                lineMatch: "^# tests (\\d+)$";
+                capture: 1;
+                example: "# tests 317";
+                why: string;
+            }> | Readonly<{
+                id: "node-test-pass-count";
+                what: "how many tests passed, off the TAP summary";
+                lineMatch: "^# pass (\\d+)$";
+                capture: 1;
+                example: "# pass 316";
+                why: string;
+            }> | Readonly<{
+                id: "node-test-fail-count";
+                what: "how many tests failed, off the TAP summary";
+                lineMatch: "^# fail (\\d+)$";
+                capture: 1;
+                example: "# fail 1";
+                why: string;
+            }> | Readonly<{
+                id: "node-test-failed-line";
+                what: "one failing test, as the TAP reporter names it";
+                lineMatch: "^not ok \\d+ ";
+                capture: null;
+                example: "not ok 7 - edit-renotify: a non-participant edit, and edits on a pending event, ping no one";
+                why: string;
+            }>)[];
         }>;
         python: Readonly<{
             suppressions: readonly (Readonly<{
@@ -393,43 +485,77 @@ export const TYPES_GENRE: Readonly<{
                 join: ":";
                 why: string;
             }>[];
+            instruments: readonly (Readonly<{
+                id: "mypy-error-line";
+                what: "one type error, as mypy prints it";
+                lineMatch: " error: ";
+                capture: null;
+                example: "packages/spawner/src/aurora_spawner/timeout_policy.py:89: error: Statement is unreachable  [unreachable]";
+                why: string;
+            }> | Readonly<{
+                id: "pytest-pass-count";
+                what: "how many tests passed, off pytest's final counts line";
+                lineMatch: "(\\d+) passed";
+                capture: 1;
+                example: "= 1 failed, 2690 passed, 3 skipped, 18 deselected, 1775 warnings in 326.12s (0:05:26) =";
+                why: string;
+            }> | Readonly<{
+                id: "pytest-failed-line";
+                what: "one failing test, as pytest's short summary names it";
+                lineMatch: "^FAILED ";
+                capture: null;
+                example: "FAILED packages/soar/tests/test_agent_registry_deprecation.py::TestAgentRegistryDeprecation::test_registry_and_discovery_equivalent_results";
+                why: string;
+            }>)[];
         }>;
     }>;
 }>;
-/**
- * THE GUARD BATTERY, KEYED BY VERDICT CLASS (hamr's ruling, PRD v1.57 §2).
- *
- * D5's battery was genre-keyed data. Under class-keyed interviews it has no
- * genre to hang from, and the ruling gives it the same home the interview took:
- * **the battery attaches to the verdict class the user picked** — not to a
- * problem-genre label, and not per catalogue KIND.
- *
- * WHY THE CLASS. What a battery is FOR is the class of dishonesty the class of
- * VERDICT admits. A green job is a job whose *done* is claimed to be
- * machine-checkable, so it carries the green battery whatever problem it came
- * from — that is the anti-suppression obligation the F87 genre earned, and it
- * must not travel with a label the interview no longer asks for.
- *
- * ATTACHMENT POINT vs CONTENTS, and the split is the whole implementation:
- *   - the battery's STRUCTURE and its un-removability key off the CLASS. That
- *     is this table: which guards exist, what they assert, which slot is the
- *     model's (`fill`), and which params are ours.
- *   - the battery's CONTENTS fill in at COMPOSITION (`compose`), because a
- *     suppression pattern, a file extension and a checker's escape hatch belong
- *     to the TOOL the declaration names, and nothing before composition knows
- *     that tool. `classGuards` resolves them from the language data below.
- *
- * A LOCKED class carries `guards: null`, not `[]`. Absent is never empty (F59):
- * `[]` would read as "this class needs no guards", which is exactly the sentence
- * D5 exists to make unsayable. Nothing ever reaches it — admission refuses a
- * locked class before its battery is asked for — and `classGuards` throws rather
- * than hand back nothing if anything ever does.
- * @type {Record<string, {locked: boolean, guards: readonly any[]|null}>}
- */
-export const CLASS_BATTERIES: Record<string, {
-    locked: boolean;
-    guards: readonly any[] | null;
+export const CLASS_BATTERIES: Readonly<{
+    green: Readonly<{
+        locked: false;
+        guards: readonly (Readonly<{
+            name: "changed-from-seed";
+            kind: "files-changed";
+            params: Readonly<{
+                requireNonEmpty: true;
+            }>;
+            compose: readonly never[];
+            fill: readonly string[];
+        }> | Readonly<{
+            name: "no-suppressions";
+            kind: "pattern-absent-in-diff";
+            params: Readonly<{}>;
+            compose: readonly string[];
+            fill: readonly never[];
+        }>)[];
+    }>;
+    'soft-green': Readonly<{
+        locked: true;
+        guards: null;
+    }>;
+    hitl: Readonly<{
+        locked: false;
+        guards: readonly (Readonly<{
+            name: "changed-from-seed";
+            kind: "files-changed";
+            params: Readonly<{
+                requireNonEmpty: true;
+            }>;
+            compose: readonly never[];
+            fill: readonly string[];
+        }> | Readonly<{
+            name: "no-suppressions";
+            kind: "pattern-absent-in-diff";
+            params: Readonly<{}>;
+            compose: readonly string[];
+            fill: readonly never[];
+        }>)[];
+    }>;
 }>;
+/** the kinds NO ONE runs as an in-run ruler — ruling 5's law, as data. A
+ * declaration that offers one is a red rather than a normalization: the signer
+ * must not read one thing and have the runner store another. */
+export const NEVER_OFFERED_KINDS: readonly string[];
 export type Red = {
     code: string;
     path: string;

package/types/authorjob.d.ts

@@ -81,14 +81,16 @@ export function refuseLockedKind(kind: string): Refusal;
  * @param {{answers: Record<string|number, any>, repoPath?: string|null, lang: string,
  *   verdictType?: string|null,
  *   questions?: Record<string|number, string>|null, generate?: Function, provider?: any,
- *   seedRef?: string|null, scout?: any, listing?: any,
+ *   seedRef?: string|null, scout?: any, listing?: any, ceilingUsd?: number|null,
+ *   onPhase?: (phase: string, data?: any) => void,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
  *   seedFn?: Function, scoutFn?: Function, listingFn?: Function,
  *   authorFn?: Function, authorOpts?: object}} o
  * @returns {Promise<{ok: boolean, refusal: Refusal|null, verdictType: string|null,
  *   closeDecl: any, seedRef: string|null, authoring: any, reds: Red[], stop: string|null,
  *   cost: any, interview: any}>}
  */
-export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, seedFn, scoutFn, listingFn, authorFn, authorOpts, }: {
+export function authorCloseForJob({ answers, repoPath, lang, verdictType, questions, generate, provider, seedRef, scout, listing, ceilingUsd, onPhase, onCall, seedFn, scoutFn, listingFn, authorFn, authorOpts, }: {
     answers: Record<string | number, any>;
     repoPath?: string | null;
     lang: string;
@@ -99,6 +101,13 @@ export function authorCloseForJob({ answers, repoPath, lang, verdictType, questi
     seedRef?: string | null;
     scout?: any;
     listing?: any;
+    ceilingUsd?: number | null;
+    onPhase?: (phase: string, data?: any) => void;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }) => void;
     seedFn?: Function;
     scoutFn?: Function;
     listingFn?: Function;

package/types/authorscout.d.ts

@@ -91,13 +91,15 @@ export function defaultSurveyor({ workdir, granted, auditPath, ctx }: {
  *
  * @param {{workdir: string, provider?: any,
  *   rounds?: number, minBytes?: number, blobMax?: number, maxTokens?: number, ctx?: boolean,
- *   attempts?: number,
+ *   attempts?: number, ceilingUsd?: number|null,
+ *   onCall?: (call: {label: string, costUsd: number|null, unpricedRounds: number}) => void,
  *   createLoop?: (o: {system: string, policy: any, onLlmResult: any, provider: any}) => any,
  *   createSurveyor?: (o: {workdir: string, granted: readonly string[], ctx: boolean}) => Promise<any>}} o
  * @returns {Promise<Survey & {raw: string, raws: ReturnType<typeof scrubRaw>[],
- *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[]}>}
+ *   calls: {label: string, costUsd: number|null, unpricedRounds: number}[],
+ *   budgetStop: 'cap-halt'|'pricing-red'|null}>}
  */
-export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, createLoop, createSurveyor, }: {
+export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, maxTokens, ctx, attempts, ceilingUsd, onCall, createLoop, createSurveyor, }: {
     workdir: string;
     provider?: any;
     rounds?: number;
@@ -106,6 +108,12 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
     maxTokens?: number;
     ctx?: boolean;
     attempts?: number;
+    ceilingUsd?: number | null;
+    onCall?: (call: {
+        label: string;
+        costUsd: number | null;
+        unpricedRounds: number;
+    }) => void;
     createLoop?: (o: {
         system: string;
         policy: any;
@@ -125,6 +133,7 @@ export function runAuthorScout({ workdir, provider, rounds, minBytes, blobMax, m
         costUsd: number | null;
         unpricedRounds: number;
     }[];
+    budgetStop: "cap-halt" | "pricing-red" | null;
 }>;
 /**
  * `git ls-tree -r --name-only <seed>` — the files as of the SEED COMMIT.
@@ -249,6 +258,16 @@ export const SURVEY_CAUSES: Readonly<{
     NON_OBJECT: "non-object";
     /** valid JSON, no content — F59's whole point, and a SEMANTIC failure */
     EMPTY_OBJECT: "empty-object";
+    /**
+     * THE SURVEY WAS NEVER ASKED FOR: the operator's money ceiling was already
+     * spent when the first attempt came due, so no call was made. Named as its own
+     * cause for the reason this enum exists at all — a new route to ABSENT has to
+     * be named, and naming it is the moment somebody decides whether it retries.
+     * This one does not, and cannot: a retry is precisely what the cap forbade.
+     * It is deliberately ABSENT of the model's own doing, and the prose says so —
+     * "the scout did not complete" would blame a model that never spoke.
+     */
+    NOT_FUNDED: "not-funded";
 }>;
 /**
  * THE MALFORMED CLASS — the only causes a retry fires on.

package/types/clock.d.ts

@@ -53,8 +53,11 @@ export function isWallTimeout(err: any, clock: Clock): boolean;
  *   run. `closeStages`: how many stages the job's close runs (W5) — each one gets
  *   the FULL `closeTimeoutMs`, so this is the multiplier on the overshoot, not a
  *   decoration. Defaults to 1, the single-predicate close. `now`: injected for
- *   tests — the default is the real clock. `priorElapsedMs`: time this attempt's
- *   PREDECESSOR already consumed (see below).
+ *   tests — the default is the real clock, and it stays injectable precisely so
+ *   every test here can drive time deterministically without a sleep. That default
+ *   is MONOTONIC (fact 4 above), not `Date.now`: a wall-clock jump — a suspend, an
+ *   NTP step, a hand-set date — must not be able to reach a signed deadline.
+ *   `priorElapsedMs`: time this attempt's PREDECESSOR already consumed (see below).
  * @returns {Clock}
  */
 export function createClock({ maxWallMs, closeStages, now, priorElapsedMs }?: {

package/types/declaredclose.d.ts

@@ -97,7 +97,8 @@ export function guardNames(closeDecl: any, verdictType: string): string[];
  * @param {any[]} stages declared stage descriptors, already validated
  * @param {(s: string) => string} [redact] the scrub, applied at THIS boundary
  * @param {{timeoutMs?: number, cwd?: string, seedRef?: string,
- *   seedTrees?: any, gapCap?: number, maxBuffer?: number, baselineMode?: 'auto'|'worktree'}} [opts]
+ *   seedTrees?: any, gapCap?: number, maxBuffer?: number, baselineMode?: 'auto'|'worktree',
+ *   humanRuling?: {decision: string, text?: string|null}|null}} [opts]
  * @returns {Promise<any>}
  */
 export function runDeclaredStages(stages: any[], redact?: (s: string) => string, opts?: {
@@ -108,6 +109,10 @@ export function runDeclaredStages(stages: any[], redact?: (s: string) => string,
     gapCap?: number;
     maxBuffer?: number;
     baselineMode?: "auto" | "worktree";
+    humanRuling?: {
+        decision: string;
+        text?: string | null;
+    } | null;
 }): Promise<any>;
 /**
  * The trend reader's input for ONE close verdict, whichever executor produced
@@ -160,11 +165,64 @@ export const DECLARED_GAP_PREFIX: "close: ";
  * it; because every declared line carries the prefix, it designates the stage's
  * whole judged output rather than a hand-picked slice of it. */
 export const DECLARED_GAP_KEEP: string;
-/** The verdict class a DECLARED close may claim. Hard, and by CONSTRUCTION
- * rather than by assertion: every live kind is a mechanical command whose
- * measurement is the truth, and the two judgment kinds are locked out at the
- * catalogue (M2) and absent from the executor (M1). Named as data so the job
- * validator reads one hierarchy table rather than hard-coding a class. */
+/**
+ * The close verdict word for a run WAITING on a person (N4 §1.3/§1.4). A
+ * literal, exported, because three readers key on it — the runner's pause
+ * branch, the ledger's excluded set, and the trend reader's blind rule — and
+ * three hand-spelled copies of one terminal is how they come to disagree.
+ *
+ * It is not in `CLOSE_FAULTS` and must never be added: a fault says the close
+ * could not render a verdict, and this says the close is not FINISHED rendering
+ * one. The first escalates; the second is a checkpoint the operator returns to.
+ */
+export const HUMAN_PAUSE: "human-pause";
+/**
+ * The RUN-level terminal names the hitl class mints one layer up from
+ * `HUMAN_PAUSE` (N4 §1.3–§1.5): the checkpoint, and the honest refusal of the
+ * operator's rerun input. Spelled once here, beside the close-verdict word they
+ * translate, for the same reason `HUMAN_PAUSE` is — the emitters (`planrun.js`),
+ * the ledger's excluded set, the resume reader (`reuse.js`), and the runner
+ * script all key on them, and hand-spelled copies of one terminal is how they
+ * come to disagree.
+ *
+ * There were three (2026-08-17): `hitl-cancel` was the signer's own terminal and
+ * is DELETED with the door it belonged to. A person who does not want to carry on
+ * now PAUSES — the same checkpoint, resumable, retired by the TTL if nobody comes
+ * back — so nothing in this tree mints that name any more. The ledger keeps the
+ * bare string in its excluded set so a spine written before this change still
+ * reads as governance rather than as a capability gap; that is a READER's
+ * backward compatibility, and deliberately not a constant a writer could reach.
+ */
+export const HITL_PAUSE: "hitl-pause";
+export const HITL_DECISION_RED: "hitl-decision-red";
+/**
+ * The terminals above that leave the run WAITING ON A PERSON — as a list, minted
+ * beside the names it holds so a reader keys on membership rather than on a
+ * spelling, and a rename here travels to every reader for free.
+ *
+ * It is deliberately NOT `reuse.js`'s `CHECKPOINT_OUTCOMES`, which is the wider
+ * RESUME list: every stop that left work on disk and an allowance unspent, money
+ * and time included. Those are governance stops the reuse loop is meant to try
+ * again under its remaining tries; this is the half no further attempt can
+ * change, because the allowance still unspent is a human answer. `CHECKPOINT_OUTCOMES`
+ * is composed FROM this list so the two can never disagree about which is which.
+ *
+ * `HITL_DECISION_RED` is not here: it is a verdict already rendered on the operator's
+ * own input, not a question still open.
+ */
+export const HUMAN_CHECKPOINTS: readonly string[];
+/** The verdict classes a DECLARED close may claim. Named as data so the job
+ * validator reads one hierarchy table rather than hard-coding a class.
+ *
+ * `hard` is by CONSTRUCTION: every mechanical kind is a command whose measurement
+ * is the truth. `hitl` joined it at N4 slice 1, and only because `human-confirms`
+ * is genuinely LIVE — the widening and the kind go in one commit, or this table
+ * admits a class the executor cannot render. The `soft` class is still absent:
+ * `judged-floor` is locked, so no declaration can reach above hitl.
+ *
+ * The direction that matters is unchanged. This says which class a declaration
+ * MAY claim; `closeCeiling` says which class its stages actually NEED. A pick
+ * below the ceiling is still the silent upgrade `class-ceiling` refuses. */
 export const DECLARED_CLOSE_CLASSES: readonly string[];
 export type Red = {
     code: string;

package/types/index.d.ts

@@ -8,13 +8,13 @@ export { validatePlan, stageClose, EXIT_TYPES, MAX_EXITS_PER_STEP, MAX_PLAN_STEP
 export { snapshotScope, evalExits } from "./exits.js";
 export { BRIDGE_SCHEMA, validateBridge, deriveStatus, listingRow, loadGate, mintBridge, appendGreen, appendRed, loadBridge, loadRegistry, saveBridge, makeRegistry, registryExists } from "./bridges.js";
 export { renderListing, selectionPrompt } from "./selection.js";
-export { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBridge, runReuse, REUSE_GRADED_RED, readResume, resumeTreeGate } from "./reuse.js";
+export { validateEnvelope, resolveTrySpec, resolveReuse, reuseSpecHash, selectBridge, runReuse, REUSE_GRADED_RED, readResume, resumeTreeGate, CHECKPOINT_OUTCOMES, PAUSE_TTL_MS, checkpointAgeGate } from "./reuse.js";
 export { classifyIncidents, foldLedger, ledgerDeltas, updateLedger, LEDGER_CLASSES } from "./ledger.js";
 export { workBranchName, prepareWorkBranch, WORK_BRANCH_PREFIX, WORK_BRANCH_RE } from "./workbranch.js";
-export { runDeclaredClose, runStage, seedRead, seedAtHead, seedListing, changedSet, makeSeedTrees, LIVE_KINDS, STOP_FAULTS, JUDGED_MARKER, EXIT_GREEN, EXIT_RED, EXIT_STOP } from "./kinds.js";
-export { validateDeclaration, normalizeDeclaration, KIND_CATALOGUE, CATALOGUE_KINDS, CATALOGUE_LIVE_KINDS, LOCKED_KINDS, TYPES_GENRE, TYPES_GENRE_TEMPLATE, GENRE_LANGUAGES, genreEnv, genreOwnedEnvNames, DIRECTIONS, BASELINES, MAX_STAGES, VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES, CLASS_BATTERIES, classGuards, closeCeiling } from "./authoring.js";
+export { runDeclaredClose, runStage, seedRead, seedAtHead, seedListing, changedSet, makeSeedTrees, LIVE_KINDS, STOP_FAULTS, JUDGED_MARKER, EXIT_GREEN, EXIT_RED, EXIT_STOP, HUMAN_DECISIONS, SEED_EXEMPT_KINDS, normalizeHumanRuling } from "./kinds.js";
+export { validateDeclaration, normalizeDeclaration, KIND_CATALOGUE, CATALOGUE_KINDS, CATALOGUE_LIVE_KINDS, LOCKED_KINDS, TYPES_GENRE, TYPES_GENRE_TEMPLATE, GENRE_LANGUAGES, genreEnv, genreOwnedEnvNames, genreInstruments, DIRECTIONS, BASELINES, MAX_STAGES, VERDICT_CLASSES, LOCKED_CLASSES, LIVE_CLASSES, CLASS_BATTERIES, classGuards, closeCeiling, NEVER_OFFERED_KINDS } from "./authoring.js";
 export { runAuthorScout, buildSeedListing, seedFileList, classifySurvey, AUTHOR_SCOUT_VERBS, SCOUT_ATTEMPTS, SURVEY_CAUSES, SCOUT_RETRY_CAUSES } from "./authorscout.js";
 export { scrubRaw, RAW_PERSIST_MAX, RAW_TRIM_MARKER } from "./text.js";
 export { authorClose, authorPrompt, declarationSchema, makeLoopGenerate, MAX_REVISIONS, QUESTION_SETS, GREEN_QUESTIONS, CLASS_STATEMENTS, questionsFor, requiredAnswersFor } from "./authorflow.js";
-export { validateCloseDecl, runDeclaredStages, declaredStages, isDeclaredClose, guardNames, closeGrade, DECLARED_GENRES, DECLARED_GAP_PREFIX, DECLARED_GAP_KEEP, DECLARED_CLOSE_CLASSES, CLOSE_DECL_FIELDS } from "./declaredclose.js";
+export { validateCloseDecl, runDeclaredStages, declaredStages, isDeclaredClose, guardNames, closeGrade, DECLARED_GENRES, DECLARED_GAP_PREFIX, DECLARED_GAP_KEEP, DECLARED_CLOSE_CLASSES, CLOSE_DECL_FIELDS, HUMAN_PAUSE, HITL_PAUSE, HITL_DECISION_RED, HUMAN_CHECKPOINTS } from "./declaredclose.js";
 export { runInterview, authorCloseForJob, assembleSpec, prepareSigning, refusalEvents, refuseLockedKind, GENRE, REFUSAL_LIB, REFUSAL_CATEGORY, AUTHORED_SPEC_FIELDS } from "./authorjob.js";

package/types/job.d.ts

@@ -158,6 +158,11 @@ export const LOCKED_TOOLS: readonly string[];
  * pattern: disclosure ≠ admission), so the ledger counts the demand and the
  * non-code rung later fills a declared slot instead of reshaping the schema. */
 export const VERDICT_TYPES: readonly string[];
+/** N4 slice 1: `hitl` is ADMITTED — the class whose *done* needs a person runs
+ * through the same signed spec, the same agent-authored plan and the same
+ * arbiter as a green job (the nine rulings, 2026-08-07; the three-button surface,
+ * 2026-08-12). `soft-green` stays declared-but-locked until its judged floor is
+ * built and proven (slice 2): a wobbly ruler must not mint anything. */
 export const LOCKED_VERDICTS: readonly string[];
 export const CADENCE_UNITS: readonly string[];
 /** SP-2: API-first; local deferred (PRD §5/§8). `clipipe-subscription` (F42,