@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/Selection.d.ts

@@ -0,0 +1,495 @@
+/**
+ * The probabilistic-selection seam: guesses may schedule work; only real
+ * dependencies decide truth.
+ *
+ * `docs/guides/defer-work-with-selection.md` describes learning, from run
+ * history, which changes *tend to* affect which flows, and letting those
+ * guesses do exactly three things: suggest extra work, postpone work that
+ * almost never fails, and order the queue. This module is the engine-store
+ * half of the proposal: the belief and verdict types, the pluggable
+ * `Selection` service, and the deterministic default layers. `PlanScheduler`
+ * is the one consumer, and it offers only **sinks** — nodes nothing in the
+ * plan depends on — because deferring a node something consumes would block
+ * or corrupt its consumers. Meta's Predictive Test Selection (ICSE-SEIP 2019)
+ * skips tests under exactly this restriction: tests are sinks.
+ *
+ * Seven v1 laws bound what a verdict may do, and the scheduler's tests assert
+ * each:
+ *
+ * 1. A verdict never enters key material and never changes a cache row: an
+ *    admitted node's step key and cached result are computed exactly as if
+ *    selection did not exist.
+ * 2. `deferred` is never passed. The node does not execute, writes no cache
+ *    row, and is journaled as a debt (`flows.engine.selection-deferred`)
+ *    that a later guess-free pass repays.
+ * 3. Only sinks are deferrable. A Defer or Propose verdict naming anything
+ *    else is ignored and journaled as an inconsistency observation —
+ *    Skyframe's `GraphInconsistencyReceiver` shape: note it, decide, never
+ *    wire the detector to /dev/null.
+ * 4. Guesses add or postpone, never remove. A node the plan requires runs
+ *    exactly as today, and the run-level `full` override restores full
+ *    execution the way `--fresh` ignores the cache.
+ * 5. Training only moves confidence: it never creates edges or touches the
+ *    journal, and misses reduce confidence faster than hits accrue it.
+ * 6. Repayment is a pure widening: `debt(runId)` keeps the v1 same-run fold,
+ *    while `debt(runId, { repaidBy })` additionally accepts settlements from
+ *    listed recertification runs.
+ * 7. The plan card, risk annotation, and read-set proposal helpers are pure
+ *    functions of plain data and require no services.
+ *
+ * Pluggability is dependency injection at the owning seam, exactly as
+ * `Reconciliation` beside it: {@link layerNoop} admits everything and is the
+ * behavioral default when no layer is provided; {@link layerHeuristic} is a
+ * pure, deterministic function of the pinned belief snapshot; a model-backed
+ * selector is a different `Layer`, lives outside this package, and this
+ * package must not grow a model dependency.
+ *
+ * Deliberately still out of scope, recorded here so the absences read as
+ * decisions rather than oversights: the model-backed selection layer (this
+ * package must not grow a model dependency), selection CLI verbs (`@smthrs/cli`
+ * owns CLI verbs and `smithers gc` drives `Retention.collect`, but no selection
+ * verbs are exposed yet), approval routing from risk (approval machinery lives
+ * elsewhere), auto-appending proposed nodes (pending human review), and
+ * scheduled recertification cadence (a product/system-flow concern; this
+ * module ships only the primitive).
+ *
+ * @since 0.1.0
+ */
+import { Journal } from "@smthrs/journal";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+/**
+ * Epoch/counter values accepted by both public schemas and SQLite.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const NonNegativeSafeInt: Schema.Int;
+/**
+ * The most `*` or `**` tokens a `SuspectedEdge.scope` may carry. Matching is
+ * linear in the path either way; the bound keeps each match cheap and refuses
+ * degenerate scopes at the write.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const maxScopeWildcards = 8;
+/**
+ * A recorded guess with a fixed shape: "changes matching this path pattern
+ * tend to affect this flow". It is a belief, not a dependency — it carries
+ * confidence and evidence, and training moves the confidence; nothing here
+ * ever enters a step key.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const SuspectedEdge: Schema.Struct<{
+    /** The path glob changed files are matched against, with at most `maxScopeWildcards` `*` or `**` tokens. */
+    readonly scope: Schema.NonEmptyString;
+    /** The flow or step name the guess says the change affects. */
+    readonly affects: Schema.NonEmptyString;
+    /** In `[0, 1]`; moved by outcomes, never by hand. */
+    readonly confidence: Schema.Number;
+    /** The edge is inert until the snapshot's `pinnedAtMs` reaches this. */
+    readonly validFromMs: Schema.Int;
+    /** References to the journal facts the guess was learned from. */
+    readonly evidence: Schema.$Array<Schema.String>;
+}>;
+/**
+ * The value form of {@link SuspectedEdge}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type SuspectedEdge = typeof SuspectedEdge.Type;
+/**
+ * The suspected edges in force for one run, pinned before planning. Pinning
+ * is what keeps selection a pure function of data in hand: a belief updated
+ * mid-run cannot change what this run defers.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const BeliefSnapshot: Schema.Struct<{
+    readonly pinnedAtMs: Schema.Int;
+    readonly edges: Schema.$Array<Schema.Struct<{
+        /** The path glob changed files are matched against, with at most `maxScopeWildcards` `*` or `**` tokens. */
+        readonly scope: Schema.NonEmptyString;
+        /** The flow or step name the guess says the change affects. */
+        readonly affects: Schema.NonEmptyString;
+        /** In `[0, 1]`; moved by outcomes, never by hand. */
+        readonly confidence: Schema.Number;
+        /** The edge is inert until the snapshot's `pinnedAtMs` reaches this. */
+        readonly validFromMs: Schema.Int;
+        /** References to the journal facts the guess was learned from. */
+        readonly evidence: Schema.$Array<Schema.String>;
+    }>>;
+}>;
+/**
+ * The value form of {@link BeliefSnapshot}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type BeliefSnapshot = typeof BeliefSnapshot.Type;
+/**
+ * What selection decided: admit the work (the default), postpone it to a
+ * guess-free pass, or propose a flow no real dependency reaches.
+ *
+ * The design draft names this union `SelectionVerdict`; here the `Selection`
+ * namespace carries that prefix, so the export is `Verdict`, the same shape
+ * `Reconciliation.Verdict` takes beside it.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const Verdict: Schema.Union<readonly [Schema.TaggedStruct<"Admit", {}>, Schema.TaggedStruct<"Defer", {
+    readonly edge: Schema.Struct<{
+        /** The path glob changed files are matched against, with at most `maxScopeWildcards` `*` or `**` tokens. */
+        readonly scope: Schema.NonEmptyString;
+        /** The flow or step name the guess says the change affects. */
+        readonly affects: Schema.NonEmptyString;
+        /** In `[0, 1]`; moved by outcomes, never by hand. */
+        readonly confidence: Schema.Number;
+        /** The edge is inert until the snapshot's `pinnedAtMs` reaches this. */
+        readonly validFromMs: Schema.Int;
+        /** References to the journal facts the guess was learned from. */
+        readonly evidence: Schema.$Array<Schema.String>;
+    }>;
+    readonly likelihood: Schema.Number;
+}>, Schema.TaggedStruct<"Propose", {
+    readonly flow: Schema.NonEmptyString;
+    readonly edge: Schema.Struct<{
+        /** The path glob changed files are matched against, with at most `maxScopeWildcards` `*` or `**` tokens. */
+        readonly scope: Schema.NonEmptyString;
+        /** The flow or step name the guess says the change affects. */
+        readonly affects: Schema.NonEmptyString;
+        /** In `[0, 1]`; moved by outcomes, never by hand. */
+        readonly confidence: Schema.Number;
+        /** The edge is inert until the snapshot's `pinnedAtMs` reaches this. */
+        readonly validFromMs: Schema.Int;
+        /** References to the journal facts the guess was learned from. */
+        readonly evidence: Schema.$Array<Schema.String>;
+    }>;
+    readonly confidence: Schema.Number;
+}>]>;
+/**
+ * The value form of {@link Verdict}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Verdict = typeof Verdict.Type;
+/**
+ * Deferral policy, inherited per directory like cache freshness windows.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Policy {
+    /**
+     * A sink whose best matched likelihood is strictly below this threshold is
+     * deferred. Zero defers nothing; a likelihood exactly at the threshold is
+     * admitted.
+     */
+    readonly deferBelow: number;
+}
+/**
+ * One deferrable candidate the scheduler offers: a plan node nothing in the
+ * plan depends on.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Candidate {
+    readonly nodeId: string;
+    /** The plan-time key: the identity the scheduler already holds. */
+    readonly planKey: string;
+    /** Historical failure rate for the sink, used only when a live edge already names it. */
+    readonly stats?: {
+        readonly failures: number;
+        readonly runs: number;
+    } | undefined;
+}
+/**
+ * Everything one selection consult sees. The scheduler builds it once per
+ * run, so a verdict is a pure function of the changed set, the plan's shape,
+ * and the pinned beliefs.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Input {
+    /** Paths this change touched, matched against edge scopes. */
+    readonly changed: ReadonlyArray<string>;
+    /** The only deferrable candidates: plan nodes with no dependents. */
+    readonly sinks: ReadonlyArray<Candidate>;
+    /**
+     * Every name the plan accounts for: its flow and its node ids. An edge
+     * whose `affects` names none of these reaches work the plan cannot see,
+     * which is what a `Propose` verdict records.
+     */
+    readonly present: ReadonlyArray<string>;
+    /** The belief snapshot pinned before planning. */
+    readonly beliefs: BeliefSnapshot;
+    readonly policy: Policy;
+}
+/**
+ * One returned verdict. `nodeId` names the offered candidate for `Admit` and
+ * `Defer`; a `Propose` names work outside the plan, so there it carries the
+ * proposed flow's name instead of a plan node id.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Selected {
+    readonly nodeId: string;
+    readonly verdict: Verdict;
+}
+/**
+ * The pluggable selector.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Service {
+    readonly select: (input: Input) => Effect.Effect<ReadonlyArray<Selected>>;
+}
+declare const Selection_base: Context.ServiceClass<Selection, "@smthrs/engine-store/Selection", Service>;
+/**
+ * Service tag for the probabilistic-selection seam.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export declare class Selection extends Selection_base {
+}
+/**
+ * Names a {@link Service} implementation as a selector.
+ *
+ * It is the identity function: the value is checked against the interface at
+ * its definition site, which is where a wrong-shaped selector should be
+ * reported rather than at whichever layer eventually provides it.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: (service: Service) => Service;
+/**
+ * Provides a {@link Service} as the {@link Selection} seam.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layer: (service: Service) => Layer.Layer<Selection>;
+/**
+ * Admits everything. This is the behavioral default: with no `Selection`
+ * layer provided the scheduler falls back to it, and a run under it is
+ * byte-identical to a run before this seam existed — same keys, same cache
+ * rows, same journal.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const makeNoop: () => Service;
+/**
+ * Provides the selector that admits everything.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layerNoop: Layer.Layer<Selection>;
+/**
+ * The deterministic default heuristics: pure, no IO, no model calls, a
+ * function of nothing but its input.
+ *
+ * An edge is *live* when its `validFromMs` has been reached at the
+ * snapshot's `pinnedAtMs` and some changed path matches its scope glob. A
+ * live edge yields likelihood equal to the maximum of its confidence and the
+ * candidate's historical `failures / max(runs, 1)` rate. A sink whose best
+ * likelihood is strictly below `policy.deferBelow` is deferred under its
+ * best edge; a sink no live edge names — or one at or above the threshold —
+ * is admitted. Stats alone never defer: they only keep a live edge from
+ * postponing a flaky sink. A live edge whose `affects` names nothing the plan
+ * contains proposes that flow, once per flow under its highest-confidence
+ * edge.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const makeHeuristic: () => Service;
+/**
+ * Provides the deterministic default heuristics.
+ *
+ * @since 0.1.0
+ * @category layers
+ */
+export declare const layerHeuristic: Layer.Layer<Selection>;
+/**
+ * One unpaid deferral: the work a guess postponed, with everything a
+ * guess-free follow-up needs to execute exactly it — the node, its
+ * content-addressed plan key, the edge that caused the postponement, and the
+ * journal position the debt was recorded at.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const DebtEntry: Schema.Struct<{
+    readonly planId: Schema.NonEmptyString;
+    readonly nodeId: Schema.NonEmptyString;
+    /** The plan-time key: the content-addressed handle repayment settles against. */
+    readonly planKey: Schema.NonEmptyString;
+    readonly edge: Schema.Struct<{
+        /** The path glob changed files are matched against, with at most `maxScopeWildcards` `*` or `**` tokens. */
+        readonly scope: Schema.NonEmptyString;
+        /** The flow or step name the guess says the change affects. */
+        readonly affects: Schema.NonEmptyString;
+        /** In `[0, 1]`; moved by outcomes, never by hand. */
+        readonly confidence: Schema.Number;
+        /** The edge is inert until the snapshot's `pinnedAtMs` reaches this. */
+        readonly validFromMs: Schema.Int;
+        /** References to the journal facts the guess was learned from. */
+        readonly evidence: Schema.$Array<Schema.String>;
+    }>;
+    readonly likelihood: Schema.Number;
+    /** Journal provenance: the durable sequence the deferral was recorded at. */
+    readonly seq: Schema.Int;
+}>;
+/**
+ * The value form of {@link DebtEntry}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type DebtEntry = typeof DebtEntry.Type;
+/**
+ * Options for {@link debt}: which recertification runs may repay this run's
+ * deferrals. The caller names the repaying runs explicitly — the fold never
+ * guesses which other runs were guess-free passes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface DebtOptions {
+    readonly repaidBy?: ReadonlyArray<string> | undefined;
+}
+/**
+ * Lists the run's unpaid deferrals by folding the journal: every
+ * `flows.engine.selection-deferred` record opens a debt under its plan key,
+ * and a later `node-settled` under the same key with a real outcome —
+ * `built`, `clean`, or `failed` — closes it. A `skipped` settlement does not:
+ * that work never ran, so it is still owed. A `failed` one does: the
+ * guess-free pass executed the work and surfaced the miss, which is the
+ * training signal the spec asks for.
+ *
+ * `debt(runId)` keeps the v1 same-run fold: only a settlement journaled
+ * under the same `runId` closes a debt. `debt(runId, { repaidBy })` is the
+ * pure widening of law 6 — settlements journaled under a listed
+ * recertification run also close, matched by plan key, and nothing else
+ * changes. `PlanScheduler.recertify` is the driver that produces such a run.
+ *
+ * The journal is read directly rather than projected into a table, for the
+ * same reason the scheduler consumes deviations from it: a deferral is a
+ * durable, replayable fact, and a second store would be a cache of one.
+ *
+ * @since 0.1.0
+ * @category queries
+ */
+export declare const debt: (runId: string, options?: DebtOptions | undefined) => Effect.Effect<readonly {
+    readonly planId: string;
+    readonly nodeId: string;
+    readonly planKey: string;
+    readonly edge: {
+        readonly scope: string;
+        readonly affects: string;
+        readonly confidence: number;
+        readonly validFromMs: number;
+        readonly evidence: readonly string[];
+    };
+    readonly likelihood: number;
+    readonly seq: number;
+}[], Journal.JournalError, Journal.Journal>;
+/**
+ * A pure risk annotation for a change, never a gate. The level comes from
+ * the live matching edges alone: `"high"` if any has confidence at or above
+ * `0.7`, `"medium"` at or above `0.4`, else `"low"`. Each contributing edge
+ * is named in `reasons` as `<scope> -> <affects> (<confidence>)`.
+ *
+ * The design draft passed the plan in this input; the pinned rule never
+ * reads it, so the shipped signature drops it — recorded here so the
+ * narrowing reads as a decision.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Risk {
+    readonly level: "low" | "medium" | "high";
+    readonly reasons: ReadonlyArray<string>;
+}
+/**
+ * Computes the {@link Risk} annotation for a change against the pinned
+ * belief snapshot. Pure: same input, same output, no services.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const risk: (input: {
+    readonly changed: ReadonlyArray<string>;
+    readonly beliefs: BeliefSnapshot;
+}) => Risk;
+/**
+ * What {@link card} renders from: settlements and deferral/proposal details
+ * as plain data, plus the recertification cadence label and an optional
+ * {@link Risk} annotation.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface CardInput {
+    readonly settlements: ReadonlyArray<{
+        readonly nodeId: string;
+        readonly outcome: string;
+    }>;
+    readonly deferrals: ReadonlyArray<{
+        readonly nodeId: string;
+        readonly likelihood: number;
+    }>;
+    readonly proposals: ReadonlyArray<{
+        readonly flow: string;
+        readonly confidence: number;
+        readonly scope: string;
+    }>;
+    readonly cadence: string;
+    readonly risk?: Risk | undefined;
+}
+/**
+ * Renders the plan card, one string per line, in the spec's row grammar:
+ * `clean` renders as `cached`, `built` as `run`, `deferred` carries its fail
+ * likelihood and the recertification cadence, each proposal names the edge
+ * that suggested it, and any other outcome renders under its own name. Pure:
+ * no IO, no services.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const card: (input: CardInput) => ReadonlyArray<string>;
+/**
+ * The workspace paths a flow's live suspected edges select: the
+ * `boundaryMode: "expected"` feeder. A path is included when any edge valid
+ * at the snapshot's pin names the flow in `affects` and matches the path
+ * with its scope glob; the result is deduplicated and keeps input order.
+ * Pure: no IO, no services. Wiring this into an agent step is future work —
+ * no agent steps exist in this repo.
+ *
+ * @since 0.1.0
+ * @category combinators
+ */
+export declare const proposeReadSet: (input: {
+    readonly beliefs: BeliefSnapshot;
+    readonly flow: string;
+    readonly paths: ReadonlyArray<string>;
+}) => ReadonlyArray<string>;
+export {};
+//# sourceMappingURL=Selection.d.ts.map

package/dist/cjs/Selection.d.ts.map

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