@dzhechkov/harness-core 0.3.150 → 0.4.2

package/dist/loop-plan.d.ts

@@ -0,0 +1,416 @@
+/**
+ * `loop-plan/1` — the versioned, typed workflow-plan schema of the loop-designer meta-factory
+ * (feature loop-designer, ADR-001).
+ *
+ * ONE semantic source of truth (the plan) with THREE derived analytical projections (AM-3 /
+ * Codex 04/Q1's "one plan, three projections" correction):
+ *   - `toOracleProjection`  → graph-diff against a hand-authored, requirement-derived oracle;
+ *   - `toLintProjection`    → CFG with synthetic entry/exit + explicit fork/join pairs for
+ *                             `loop-lint.ts` (barrier post-dominance, budget, reachability);
+ *   - `toTraceProjection`   → expected runtime invariants for `loop-trace.ts::runInvariants`.
+ * No consumer reads `plan.steps`/`plan.deps`/… directly — enforced by the layer-1 source grep
+ * `loop-projection-consumers.test.ts` (empty allowlist).
+ *
+ * This schema deliberately carries NO LangGraph branding and adopts none of LangGraph's execution
+ * semantics (AM-7): it is an internally-versioned typed plan that names its own semantics —
+ * `RetryProfile.maxAttempts` INCLUDES the initial attempt (AM-4), retryable failure classes are a
+ * CLOSED serializable enum (never a callable), `cache` (keyed on normalized input) is a SEPARATE
+ * identity from `checkpointing` (keyed on execution position — INV-6).
+ *
+ * Extension point: any top-level or per-step key matching /^x-/ is accepted by `parsePlan`,
+ * preserved by `normalizePlan` in canonical order (so it participates in `planDigest`), and
+ * ignored by `validatePlan` and all three projections (narrowing N-2 — vendor/consumer data such
+ * as a cfr case-set rides as `x-caseSet` without schema surgery).
+ *
+ * Everything here is pure (node:crypto for the digest only — no fs, no clock, no randomness).
+ */
+export declare const LOOP_PLAN_SCHEMA = "loop-plan/1";
+/** Blob/schema version stamp read by scripts/gen-loop-blobs.mjs (this module is NOT a blob source
+ * today; the stamp keeps the convention uniform for every loop-designer module). */
+export declare const LOOP_PLAN_MODULE_VERSION = "1.0.0";
+export type StepKind = 'agent' | 'fanout' | 'join' | 'gate' | 'pause';
+export type Deliverable = 'return-value' | 'file';
+export type ConcurrencyShape = 'barrier' | 'pipeline';
+export type DispatchRoute = 'inline' | 'codex-wrapper' | 'codex-exec';
+/** CLOSED serializable failure-class enum (AM-4 — never a callable). */
+export declare const RETRYABLE_FAILURE_CLASSES: readonly ["timeout", "transport", "malformed-output", "policy-refusal"];
+export type FailureClass = (typeof RETRYABLE_FAILURE_CLASSES)[number];
+/** The closed join-policy set (INV-3). `quorum:<n>` is validated by pattern. */
+export declare const JOIN_POLICIES: readonly ["all-declared", "all-activated", "any"];
+export declare const QUORUM_RE: RegExp;
+/**
+ * Retry semantics owned by THIS schema (AM-4 — no verbatim LangGraph RetryPolicy copy):
+ * - `maxAttempts` INCLUDES the initial attempt: `1` = run once, never retry (the default for
+ *   `kind:'agent'` steps — agent stages are expensive and rarely idempotent).
+ * - `retryableFailureClasses` is a CLOSED serializable enum list — a function value is a parse error.
+ *
+ * v1 NARROWING (QE round 6): the retry-TIMING family — `initialDelayMs` / `backoffMultiplier` /
+ * `maxDelayMs` / `jitter` — is NOT enacted by loop-plan/1 v1 and is VALIDATED-AWAY
+ * (`ENACT-RETRY-TIMING`). v1 retries are IMMEDIATE. Rationale: this field family reopened a
+ * reviewer blocker in every round it was "enacted" (round-4: the member projection dropped
+ * `initialDelayMs`; round-5: `backoffMultiplier`/`maxDelayMs` without `initialDelayMs` validated
+ * and vanished symmetrically; negative delays and a zero multiplier validated then were silently
+ * skipped). A plan must not validate while promising unperformed timing — see roadmap.
+ */
+export interface RetryProfile {
+    /** Total attempt budget, INCLUDING the initial attempt (1 = no retry). */
+    maxAttempts: number;
+    /** NOT ENACTED in v1 — rejected by ENACT-RETRY-TIMING (retries are immediate); see roadmap. Milliseconds. */
+    initialDelayMs?: number;
+    /** NOT ENACTED in v1 — rejected by ENACT-RETRY-TIMING; see roadmap. */
+    backoffMultiplier?: number;
+    /** NOT ENACTED in v1 — rejected by ENACT-RETRY-TIMING; see roadmap. Milliseconds. */
+    maxDelayMs?: number;
+    /** NOT ENACTED in v1 — rejected by ENACT-RETRY-TIMING (the sandbox has no randomness); see roadmap. */
+    jitter?: 'none' | 'full' | 'deterministic';
+    /** CLOSED enum of retryable failure classes — never a callable (AM-4). */
+    retryableFailureClasses?: FailureClass[];
+}
+/**
+ * Cache policy — a SEPARATE identity from checkpointing (INV-6): cache is keyed on the step's
+ * NORMALIZED INPUT; a checkpoint is keyed on EXECUTION POSITION. A step may be cacheable only
+ * when `idempotent: true` and its deliverable has no external side effect.
+ */
+export interface CachePolicy {
+    enabled: boolean;
+    /** The canonical cache-key composition (documented, fixed for schema/1). */
+    keyedOn: 'workflowVersion+stageVersion+normalizedInput+model+promptHash+toolSchemaHash+parameters+artifactHashes';
+    ttl?: string;
+    invalidateOn?: string[];
+}
+export interface LoopStep {
+    stepId: string;
+    title?: string;
+    kind: StepKind;
+    /** The phase this step reports under; `meta.phases` order must match first-reference order (INV-7). */
+    phase: string;
+    deps?: string[];
+    /** Prompt seed rendered into the GENERATED region (part of the exec fingerprint's prompt axis). */
+    prompt?: string;
+    artifacts?: {
+        reads?: string[];
+        writes?: string[];
+    };
+    /** For fanout members: barrier (all A, then all B) vs pipeline (per-item chains). */
+    concurrency?: ConcurrencyShape;
+    /** Model spec for this step (resolved by the model-resolver blob when set). */
+    model?: string | null;
+    /** What the step delivers: its return value, or a file written out-of-band. Default 'return-value'. */
+    deliverable?: Deliverable;
+    idempotent?: boolean;
+    retry?: RetryProfile;
+    /** Cacheable only when idempotent and side-effect-free (INV-6). */
+    cacheable?: boolean;
+    cache?: CachePolicy;
+    /** NOT ENACTED in v1 — rejected by ENACT-CKPT-OPT (per-step checkpoint granularity is deferred;
+     * `checkpointing.enabled` checkpoints EVERY top-level agent step). The field false-flipped the
+     * exec fingerprint in two review rounds; see roadmap. */
+    checkpoint?: boolean;
+    budget?: {
+        maxAgents: number;
+    };
+    /** Dispatch route. v1 NARROWING (QE round 6): only 'inline' is enacted — 'codex-wrapper' and
+     * 'codex-exec' are VALIDATED-AWAY (ENACT-DISPATCH). The fire-and-forget wrapper returns a stub
+     * that reads as a clean result, and codex-exec had no live-proven enactment here; see roadmap. */
+    dispatch?: DispatchRoute;
+    /** For kind:'pause' — which declared pause state this step returns. */
+    pauseState?: string;
+    /** Extension keys (x-…) are preserved and digested, never validated. */
+    [xKey: `x-${string}`]: unknown;
+}
+export interface LoopFanout {
+    /** The stepId of the kind:'fanout' step this config belongs to. */
+    stage: string;
+    /** The member registry the fanout draws from — REQUIRED (INV-2). */
+    registry: string[];
+    /** Hard concurrency bound — REQUIRED, >= 1 (INV-2; unbounded fanout is unrepresentable-invalid). */
+    maxFanout: number;
+    dedup?: boolean;
+    reasonRequired?: boolean;
+    /** Per-item step chain (pipeline shape) — stepIds run in sequence per member. */
+    chain?: string[];
+}
+export interface LoopJoin {
+    /** The stepId of the kind:'join' step. */
+    stage: string;
+    /** The fanout stage this join closes (INV-3: every parallel region names its join). */
+    forStage: string;
+    branchSchema?: {
+        caveats?: string[];
+    };
+    /** From the closed set: all-declared | all-activated | any | quorum:<n>. */
+    joinPolicy: string;
+    onInvalid?: string;
+}
+export interface LoopGate {
+    stepId: string;
+    kind: string;
+    failRoute?: string;
+    maxRedos?: number;
+}
+export interface LoopPause {
+    /** Typed pause state name (checkpoint-return/re-invoke — never a generic interrupt, C-4). */
+    state: string;
+    payloadSchema?: Record<string, unknown>;
+    /** The args key a re-invoke supplies to resume past this pause. */
+    resumeArg: string;
+}
+/** The 5 explicit opt-in subsystem booleans — default ALL false. `model-resolver` is NOT an
+ * opt-in: it auto-includes whenever any `step.model` is set (DDD resolution, 04 §3.1). */
+export interface LoopSubsystems {
+    checkpoints?: boolean;
+    /** Default OFF — the health-advisor PHI lesson (AM-9): capture is never on by default. */
+    trainingPairs?: boolean;
+    usageAdaptive?: boolean;
+    challengePanel?: boolean;
+    /** NOT ENACTED in v1 — enabling it is rejected (ENACT-SUBSYS): codex dispatch routes are
+     * validated-away (ENACT-DISPATCH), so the subsystem blob would inject with no call sites. */
+    codexDispatch?: boolean;
+}
+export interface LoopPlan {
+    schema: typeof LOOP_PLAN_SCHEMA;
+    name: string;
+    description: string;
+    whenToUse: string;
+    steps: LoopStep[];
+    gates?: LoopGate[];
+    fanouts?: LoopFanout[];
+    joins?: LoopJoin[];
+    pauses?: LoopPause[];
+    /** `schemaVersion` is NOT ENACTED in v1 — rejected by ENACT-CKPT-OPT (v1 pins `loop-ckpt-1`);
+     * the declared-vs-default distinction false-flipped the fingerprint in round 3; see roadmap. */
+    checkpointing?: {
+        enabled: boolean;
+        schemaVersion?: string;
+    };
+    subsystems?: LoopSubsystems;
+    trace?: {
+        emit: boolean;
+    };
+    [xKey: `x-${string}`]: unknown;
+}
+export interface ParseError {
+    path: string;
+    message: string;
+}
+export interface Diagnostic {
+    invariant: string;
+    path: string;
+    message: string;
+}
+/**
+ * THE ItemKey domain — ONE regex object, shared by the PLAN layer (`fanouts[].registry` items) and
+ * the TRACE layer (`loop-trace.ts`'s dispatch-event `itemKey`/`stepId` VO check). It is the SAME
+ * object, not a copy: `ITEM_KEY_RE === TRACE_KEY_RE` is asserted by test, so the two layers can
+ * never drift apart.
+ *
+ * QE round-7 (Codex round-6 R2/R3, MEASURED): `registry: ["hello world"]` parsed and validated
+ * with ZERO findings — INV-2 checked only that the registry was a non-empty string array — and the
+ * run then behaved DIFFERENTLY depending on a field that is supposed to be observational only:
+ * with `trace.emit:false` it COMPLETED with one member call; with `trace.emit:true` it died BEFORE
+ * the member call with `loop-trace: refusing non-conforming event (itemKey fails its VO regex)`.
+ * A declared, retained field whose plan-domain and runtime-domain disagree is exactly the "a valid
+ * plan promises what the runtime will not perform" class; the domain is now ONE, checked at parse.
+ */
+export declare const ITEM_KEY_RE: RegExp;
+/** The ItemKey validator both layers use (the plan half; the trace half calls the same regex). */
+export declare function isItemKey(v: unknown): v is string;
+/**
+ * COLLISION-RESISTANT stepId → JS-identifier lowering, with parse-time collision rejection by
+ * IDENT-1 (QE round-6; the round-5 reviewer's named third class: `a-b` and `a.b` both lowered to
+ * `a_b`, so two LEGAL distinct stepIds rendered `SyntaxError: Identifier 'USER_PROMPT_a_b' has
+ * already been declared`). A lossless id (already a pure `[A-Za-z0-9_]` word) lowers to itself; a
+ * LOSSY sanitization always appends an 8-hex sha256 suffix of the ORIGINAL id, so two distinct ids
+ * no longer collide by ACCIDENT. The IDENT-1 parse check is the belt — both for crafted names that
+ * imitate the suffix form and for the (astronomically unlikely by accident, cheap for an attacker)
+ * truncated-hash collision. This function is NOT injective; see the honesty note below.
+ *
+ * HONESTY NOTE (QE round-7 — the round-6 reviewer's caveat, CONCEDED verbatim: "an 8-hex truncated
+ * hash is not itself mathematically injective; the parse belt supplies the actual safety"). A
+ * 32-bit truncation of sha256 is COLLISION-RESISTANT, not INJECTIVE: over a 32-bit codomain,
+ * distinct originals with the same sanitized stem CAN in principle share a suffix (finding such a
+ * pair costs ~2^16 tries by the birthday bound — cheap for an ATTACKER, unreachable by accident).
+ * So the guarantee this function carries alone is "no ACCIDENTAL collision"; the guarantee that a
+ * plan with two ids lowering to one identifier is REJECTED is IDENT-1's (parsePlan), which
+ * compares the ACTUAL lowered strings and needs no injectivity assumption. IDENT-1 is the safety
+ * belt; widening the suffix would only move the bound, never remove the need for the belt.
+ */
+export declare function stepIdent(stepId: string): string;
+export type FieldDomain = {
+    t: 'bespoke';
+} | {
+    t: 'string';
+} | {
+    t: 'boolean';
+} | {
+    t: 'number';
+} | {
+    t: 'posInt';
+} | {
+    t: 'enum';
+    values: readonly string[];
+} | {
+    t: 'string[]';
+} | {
+    t: 'record';
+} | {
+    t: 'record[]';
+} | {
+    t: 'string|null';
+};
+/** Keys are `<Interface>.<field>` plus `<inlineField>.<sub>` — EXACTLY the keys the honesty test
+ * extracts from this file's interface source (both directions asserted there). */
+export declare const FIELD_DOMAINS: Record<string, FieldDomain>;
+/** `<iface>` → its accepted field names, derived from FIELD_DOMAINS (never hand-written). */
+export declare const KNOWN_KEYS: Record<string, ReadonlySet<string>>;
+/** The record kinds that carry the documented `[xKey: \`x-${string}\`]` vendor escape — i.e. the
+ * ONLY scopes where an `x-` key is accepted (Codex round-6: "Restrict `x-` acceptance to its
+ * documented scopes"). The honesty test derives this set from the interface SOURCE (which
+ * interfaces declare the index signature) in both directions, so it cannot drift either. */
+export declare const X_KEY_IFACES: ReadonlySet<string>;
+/**
+ * REQUIRED fields per record kind (QE round-6; Codex round-5 R1 blocker 1: a `fanouts[]` record
+ * with the REQUIRED `stage` field ABSENT parsed, validated, and rendered a zero-agent COMPLETED
+ * run — `parsePlan` checked only PRESENT fields and XREF-1 skipped `undefined` targets).
+ * Same discipline as FIELD_DOMAINS: the table is TOTAL over the schema's record kinds, and the
+ * honesty test derives the expected sets from the interface SOURCE (fields declared without `?`),
+ * so a new required field cannot ship unenforced and a stale entry cannot linger.
+ *
+ * Keys marked in OWNED_ABSENCE have dedicated absence diagnostics in parsePlan (kept verbatim for
+ * message stability); the REQUIRED pass enforces everything else.
+ */
+export declare const REQUIRED_FIELDS: Record<string, readonly string[]>;
+export declare const STEP_FIELD_KINDS: Record<string, readonly StepKind[]>;
+export interface CrossRef {
+    /** '<collection>[].<field>' — the referencing field, as documented in diagnostics. */
+    ref: string;
+    /** Legal target step kinds. A reference to an existing step of another kind is XREF-1. */
+    targetKinds: readonly StepKind[];
+    /** 'terminal:<name>' allowed in place of a stepId (gate terminal routes). */
+    allowTerminal?: true;
+    /** How the renderer CONSUMES an accepted record (doc — the UNCONSUMED-1 checks assert the
+     * reverse direction where a skip/no-op is otherwise possible). */
+    consumes: string;
+    /** Enumerate every reference instance this field carries in a plan (the table is self-contained:
+     * a new entry cannot ship without its accessor, so it cannot silently validate nothing). */
+    get: (plan: LoopPlan) => {
+        target: string | undefined;
+        path: string;
+    }[];
+}
+export declare const CROSS_REFS: readonly CrossRef[];
+/**
+ * Parse a raw JSON value into a LoopPlan, or return the ParseError list (union return per the
+ * behavioral contract). Structural only — semantic invariants live in `validatePlan`.
+ * `x-` keys at the top level and per step are accepted and carried through verbatim.
+ * A callable/`function` value anywhere in a retry field is a PARSE error (AM-4).
+ */
+export declare function parsePlan(json: unknown): LoopPlan | ParseError[];
+/** True when a parsePlan return is the error branch of the union. */
+export declare function isParseErrors(v: LoopPlan | ParseError[]): v is ParseError[];
+/**
+ * Semantic validation — INV-1…8 (one diagnostic per violated invariant instance, each naming the
+ * invariant it defends). Pure; never throws.
+ */
+export declare function validatePlan(plan: LoopPlan): Diagnostic[];
+/**
+ * Canonical form: object keys sorted (x- keys included, so they participate in the digest),
+ * cosmetic fields stripped, undefined dropped, step/array ORDER preserved (order is semantic —
+ * INV-7 phase order derives from it).
+ */
+export declare function normalizePlan(plan: LoopPlan): LoopPlan;
+/** sha256 over the canonical JSON of the normalized plan. */
+export declare function planDigest(plan: LoopPlan): string;
+export interface OracleProjection {
+    kind: 'oracle-projection/1';
+    steps: {
+        id: string;
+        kind: StepKind;
+        phase: string;
+    }[];
+    transitions: {
+        from: string;
+        to: string;
+        kind: 'dep';
+    }[];
+    regions: {
+        fanout: string;
+        join: string;
+        joinPolicy: string;
+        maxFanout: number;
+        registry: string[];
+        chain: string[];
+    }[];
+}
+/** Normalized logical graph for the oracle diff: steps + typed transitions + region membership,
+ * canonical (sorted) ordering, cosmetic fields gone. */
+export declare function toOracleProjection(plan: LoopPlan): OracleProjection;
+export interface LintProjection {
+    kind: 'lint-projection/1';
+    /** CFG nodes: synthetic 'entry'/'exit' + every stepId. */
+    nodes: string[];
+    /** Directed edges entry→roots, dep edges, leaves→exit. */
+    edges: {
+        from: string;
+        to: string;
+    }[];
+    /** Explicit fork/join pairs with the branches activated between them. */
+    forkJoinPairs: {
+        fork: string;
+        join: string;
+        policy: string;
+        branches: string[];
+        maxFanout: number;
+        registrySize: number;
+    }[];
+    /** Phase first-reference order (INV-7 cross-check). */
+    phaseOrder: string[];
+    /** Per-step lint facts (budget, retry, dispatch, deliverable, cache) — the rule inputs. */
+    facts: {
+        id: string;
+        kind: StepKind;
+        budgetMaxAgents: number | null;
+        maxAttempts: number;
+        idempotent: boolean;
+        deliverable: Deliverable;
+        dispatch: DispatchRoute;
+        cacheable: boolean;
+        writes: string[];
+    }[];
+    pauses: {
+        state: string;
+        resumeArg: string;
+    }[];
+    checkpointingEnabled: boolean;
+    traceEmit: boolean;
+}
+/** Control-flow/dependency graph with synthetic entry/exit and explicit fork/join pairs —
+ * the ONLY plan view `loop-lint.ts` consumes. */
+export declare function toLintProjection(plan: LoopPlan): LintProjection;
+export interface TraceProjection {
+    kind: 'trace-projection/1';
+    /** Expected happens-before edges: every dispatch of `step` must come after the settle of each
+     * dep. Only DISPATCHING step kinds (agent/gate) appear — fanout/join/pause are structural
+     * pseudo-steps that emit no trace events of their own (their ordering lives in `regions`). */
+    happensBefore: {
+        step: string;
+        afterSettleOf: string;
+    }[];
+    /** Parallel regions with the runtime bound + concurrency shape the trace must exhibit.
+     * `after` = the dispatching steps that depend on the region (fanout or join) — the trace-visible
+     * witnesses of the barrier. */
+    regions: {
+        fanout: string;
+        join: string;
+        joinPolicy: string;
+        maxFanout: number;
+        members: string[];
+        shape: ConcurrencyShape;
+        after: string[];
+    }[];
+    /** Steps expected to appear in the trace, keyed by stepId (iteration/attempt keys are runtime axes). */
+    expectedSteps: string[];
+}
+/** Expected runtime invariants — the ONLY plan view `loop-trace.ts::runInvariants` consumes. */
+export declare function toTraceProjection(plan: LoopPlan): TraceProjection;
+//# sourceMappingURL=loop-plan.d.ts.map

package/dist/loop-plan.d.ts.map

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