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

package/dist/cjs/Selection.js

@@ -0,0 +1,288 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Selection_exports = {};
+__export(Selection_exports, {
+  BeliefSnapshot: () => BeliefSnapshot,
+  DebtEntry: () => DebtEntry,
+  NonNegativeSafeInt: () => NonNegativeSafeInt,
+  Selection: () => Selection,
+  SuspectedEdge: () => SuspectedEdge,
+  Verdict: () => Verdict,
+  card: () => card,
+  debt: () => debt,
+  layer: () => layer,
+  layerHeuristic: () => layerHeuristic,
+  layerNoop: () => layerNoop,
+  make: () => make,
+  makeHeuristic: () => makeHeuristic,
+  makeNoop: () => makeNoop,
+  maxScopeWildcards: () => maxScopeWildcards,
+  proposeReadSet: () => proposeReadSet,
+  risk: () => risk
+});
+module.exports = __toCommonJS(Selection_exports);
+var import_journal = require("@smthrs/journal");
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+const Confidence = Schema.Number.check(
+  Schema.isGreaterThanOrEqualTo(0),
+  Schema.isLessThanOrEqualTo(1)
+);
+const NonNegativeSafeInt = Schema.Int.check(
+  Schema.isGreaterThanOrEqualTo(0),
+  Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+);
+const maxScopeWildcards = 8;
+const scopeWildcards = (scope) => scope.match(/\*\*|\*/g)?.length ?? 0;
+const SuspectedEdge = Schema.Struct({
+  /** The path glob changed files are matched against, with at most `maxScopeWildcards` `*` or `**` tokens. */
+  scope: Schema.NonEmptyString.check(
+    Schema.makeFilter(
+      (scope) => scopeWildcards(scope) <= maxScopeWildcards ? void 0 : `scope carries more than ${maxScopeWildcards} * or ** wildcards`
+    )
+  ),
+  /** The flow or step name the guess says the change affects. */
+  affects: Schema.NonEmptyString,
+  /** In `[0, 1]`; moved by outcomes, never by hand. */
+  confidence: Confidence,
+  /** The edge is inert until the snapshot's `pinnedAtMs` reaches this. */
+  validFromMs: NonNegativeSafeInt,
+  /** References to the journal facts the guess was learned from. */
+  evidence: Schema.Array(Schema.String)
+});
+const BeliefSnapshot = Schema.Struct({
+  pinnedAtMs: NonNegativeSafeInt,
+  edges: Schema.Array(SuspectedEdge)
+});
+const Verdict = Schema.Union([
+  Schema.TaggedStruct("Admit", {}),
+  Schema.TaggedStruct("Defer", { edge: SuspectedEdge, likelihood: Confidence }),
+  Schema.TaggedStruct("Propose", { flow: Schema.NonEmptyString, edge: SuspectedEdge, confidence: Confidence })
+]);
+class Selection extends Context.Service()("@smthrs/engine-store/Selection") {
+}
+const make = (service) => service;
+const layer = (service) => Layer.succeed(Selection, service);
+const makeNoop = () => ({
+  select: Effect.fn("Selection.select")(
+    (input) => Effect.succeed(
+      input.sinks.map((candidate) => ({ nodeId: candidate.nodeId, verdict: { _tag: "Admit" } }))
+    )
+  )
+});
+const layerNoop = Layer.sync(Selection, makeNoop);
+const compileScope = (scope) => {
+  const tokens = scope.split("**").flatMap((segment, index) => [
+    ...index === 0 ? [] : ["**"],
+    ...segment
+  ]);
+  const close = (states) => {
+    for (let index = 0; index < tokens.length; index++) {
+      if (states[index] === 1 && (tokens[index] === "*" || tokens[index] === "**")) states[index + 1] = 1;
+    }
+    return states;
+  };
+  return (path) => {
+    let states = close(new Uint8Array(tokens.length + 1).fill(1, 0, 1));
+    for (const char of path) {
+      const next = new Uint8Array(tokens.length + 1);
+      let live = false;
+      for (let index = 0; index < tokens.length; index++) {
+        if (states[index] !== 1) continue;
+        const token = tokens[index];
+        const target = token === "**" || token === "*" && char !== "/" ? index : token === "?" && char !== "/" || token === char ? index + 1 : -1;
+        if (target >= 0) {
+          next[target] = 1;
+          live = true;
+        }
+      }
+      if (!live) return false;
+      states = close(next);
+    }
+    return states[tokens.length] === 1;
+  };
+};
+const makeScopeMatcher = () => {
+  const matchers = /* @__PURE__ */ new Map();
+  return (scope, path) => {
+    let matcher = matchers.get(scope);
+    if (matcher === void 0) {
+      matcher = compileScope(scope);
+      matchers.set(scope, matcher);
+    }
+    return matcher(path);
+  };
+};
+const liveEdges = (beliefs, paths) => {
+  const matchesScope = makeScopeMatcher();
+  return beliefs.edges.filter(
+    (edge) => edge.validFromMs <= beliefs.pinnedAtMs && paths.some((path) => matchesScope(edge.scope, path))
+  );
+};
+const makeHeuristic = () => ({
+  select: Effect.fn("Selection.select")(
+    (input) => Effect.sync(() => {
+      const live = liveEdges(input.beliefs, input.changed);
+      const verdicts = [];
+      for (const candidate of input.sinks) {
+        let best = void 0;
+        for (const edge of live) {
+          if (edge.affects !== candidate.nodeId) continue;
+          if (best === void 0 || edge.confidence > best.confidence) best = edge;
+        }
+        const failureLikelihood = candidate.stats === void 0 ? 0 : candidate.stats.failures / Math.max(candidate.stats.runs, 1);
+        const likelihood = Math.max(best?.confidence ?? 0, failureLikelihood);
+        verdicts.push(
+          best !== void 0 && likelihood < input.policy.deferBelow ? { nodeId: candidate.nodeId, verdict: { _tag: "Defer", edge: best, likelihood } } : { nodeId: candidate.nodeId, verdict: { _tag: "Admit" } }
+        );
+      }
+      const present = new Set(input.present);
+      const proposals = /* @__PURE__ */ new Map();
+      for (const edge of live) {
+        if (present.has(edge.affects)) continue;
+        const existing = proposals.get(edge.affects);
+        if (existing === void 0 || edge.confidence > existing.confidence) proposals.set(edge.affects, edge);
+      }
+      for (const [flow, edge] of proposals) {
+        verdicts.push({ nodeId: flow, verdict: { _tag: "Propose", flow, edge, confidence: edge.confidence } });
+      }
+      return verdicts;
+    })
+  )
+});
+const layerHeuristic = Layer.sync(Selection, makeHeuristic);
+const DebtEntry = Schema.Struct({
+  planId: Schema.NonEmptyString,
+  nodeId: Schema.NonEmptyString,
+  /** The plan-time key: the content-addressed handle repayment settles against. */
+  planKey: Schema.NonEmptyString,
+  edge: SuspectedEdge,
+  likelihood: Schema.Number,
+  /** Journal provenance: the durable sequence the deferral was recorded at. */
+  seq: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+});
+const DeferredPayload = Schema.Struct({
+  planId: Schema.NonEmptyString,
+  nodeId: Schema.NonEmptyString,
+  planKey: Schema.NonEmptyString,
+  edge: SuspectedEdge,
+  likelihood: Schema.Number
+});
+const decodeDeferred = Schema.decodeUnknownOption(DeferredPayload);
+const SettledPayload = Schema.Struct({
+  planKey: Schema.NonEmptyString,
+  outcome: Schema.String
+});
+const decodeSettled = Schema.decodeUnknownOption(SettledPayload);
+const debt = Effect.fn("Selection.debt")(
+  (runId, options) => Effect.gen(function* () {
+    const journal = yield* import_journal.Journal.Journal;
+    const owed = /* @__PURE__ */ new Map();
+    const fold = (run, closesOnly) => Effect.gen(function* () {
+      let cursor = void 0;
+      while (true) {
+        const page = yield* journal.entries({
+          runId: run,
+          ...cursor === void 0 ? {} : { after: cursor },
+          limit: 512
+        });
+        for (const entry of page.entries) {
+          cursor = entry.seq;
+          if (!closesOnly && entry.eventType === "flows.engine.selection-deferred") {
+            const payload2 = decodeDeferred(entry.payload);
+            if (Option.isNone(payload2)) continue;
+            owed.set(payload2.value.planKey, { ...payload2.value, seq: entry.seq });
+            continue;
+          }
+          if (entry.eventType !== "flows.engine.node-settled") continue;
+          const payload = decodeSettled(entry.payload);
+          if (Option.isNone(payload)) continue;
+          const outcome = payload.value.outcome;
+          if (outcome === "built" || outcome === "clean" || outcome === "failed") {
+            owed.delete(payload.value.planKey);
+          }
+        }
+        if (!page.hasMore) break;
+      }
+    });
+    yield* fold(runId, false);
+    for (const repayer of options?.repaidBy ?? []) {
+      yield* fold(repayer, true);
+    }
+    return [...owed.values()];
+  })
+);
+const risk = (input) => {
+  const live = liveEdges(input.beliefs, input.changed);
+  const level = live.some((edge) => edge.confidence >= 0.7) ? "high" : live.some((edge) => edge.confidence >= 0.4) ? "medium" : "low";
+  return {
+    level,
+    reasons: live.map((edge) => `${edge.scope} -> ${edge.affects} (${edge.confidence})`)
+  };
+};
+const card = (input) => {
+  const likelihoods = new Map(input.deferrals.map((deferral) => [deferral.nodeId, deferral.likelihood]));
+  const row = (label, rest) => `  ${label.padEnd(8)}  ${rest}`;
+  const lines = [];
+  for (const settlement of input.settlements) {
+    if (settlement.outcome === "clean") lines.push(row("cached", settlement.nodeId));
+    else if (settlement.outcome === "built") lines.push(row("run", settlement.nodeId));
+    else if (settlement.outcome === "deferred") {
+      const likelihood = likelihoods.get(settlement.nodeId) ?? 0;
+      lines.push(row("deferred", `${settlement.nodeId}    fail likelihood ${likelihood} - recert ${input.cadence}`));
+    } else lines.push(row(settlement.outcome, settlement.nodeId));
+  }
+  for (const proposal of input.proposals) {
+    lines.push(row("proposed", `${proposal.flow}    suspected edge ${proposal.confidence} - ${proposal.scope} touched`));
+  }
+  if (input.risk !== void 0) {
+    lines.push(row("risk", `${input.risk.level} - ${input.risk.reasons.join("; ")}`));
+  }
+  return lines;
+};
+const proposeReadSet = (input) => {
+  const edges = input.beliefs.edges.filter(
+    (edge) => edge.validFromMs <= input.beliefs.pinnedAtMs && edge.affects === input.flow
+  );
+  const matchesScope = makeScopeMatcher();
+  const seen = /* @__PURE__ */ new Set();
+  const selected = [];
+  for (const path of input.paths) {
+    if (seen.has(path)) continue;
+    if (edges.some((edge) => matchesScope(edge.scope, path))) {
+      seen.add(path);
+      selected.push(path);
+    }
+  }
+  return selected;
+};
+//# sourceMappingURL=Selection.js.map

package/dist/cjs/Selection.js.map

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

package/dist/cjs/SelectionStore.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Durable suspected-edge storage for probabilistic selection.
+ *
+ * The store persists advisory beliefs only: training moves edge confidence and
+ * appends evidence, but it never writes scheduler journal records, step keys,
+ * or cache rows (law 5). The edge and snapshot schemas are `Selection`'s own —
+ * one source of truth, so a stored edge is by construction what
+ * `Selection.select` consumes. Evidence entries stay strings: training appends
+ * the observation JSON-encoded, so audits can replay the asymmetric rule
+ * without the schema forking from `Selection.SuspectedEdge`.
+ *
+ * Model-backed selection, CLI verbs, approval routing, auto-appending
+ * proposals, and scheduled recertification cadence are deliberately out of
+ * scope here: `engine-store` must not grow a model dependency, no selection
+ * CLI verbs are exposed yet, approval routing belongs to
+ * `@smthrs/control`, proposal admission still needs human product review, and
+ * cadence belongs to a system-flow/product layer rather than the primitive
+ * store.
+ *
+ * @since 0.1.0
+ */
+import { DurableWriter } from "@smthrs/database/DurableWriter";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as Selection from "./Selection.ts";
+/**
+ * Training outcomes for a suspected edge: a `hit` is a recertified deferral
+ * that passed, a `miss` is one that failed — the guess was confidently wrong.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const TrainingOutcome: Schema.Literals<readonly ["hit", "miss"]>;
+/**
+ * Training outcomes for a suspected edge.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type TrainingOutcome = typeof TrainingOutcome.Type;
+/**
+ * One observed result for a stored suspected edge.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const TrainingObservation: Schema.Struct<{
+    readonly scope: Schema.NonEmptyString;
+    readonly affects: Schema.NonEmptyString;
+    readonly outcome: Schema.Literals<readonly ["hit", "miss"]>;
+}>;
+/**
+ * One observed result for a stored suspected edge.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type TrainingObservation = typeof TrainingObservation.Type;
+/**
+ * Stable selection-store failure codes.
+ *
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const SelectionStoreErrorCode: Schema.Literals<readonly ["invalid_input", "decode_failed", "persistence_failed"]>;
+/**
+ * Stable selection-store failure codes.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type SelectionStoreErrorCode = typeof SelectionStoreErrorCode.Type;
+declare const SelectionStoreError_base: Schema.Class<SelectionStoreError, Schema.TaggedStruct<"@smthrs/engine-store/SelectionStoreError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "decode_failed", "persistence_failed"]>;
+    readonly message: Schema.String;
+    readonly scope: Schema.optional<Schema.String>;
+    readonly affects: Schema.optional<Schema.String>;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A rejected public value, corrupt stored row, or unavailable database.
+ *
+ * @category errors
+ * @since 1.0.0
+ */
+export declare class SelectionStoreError extends SelectionStoreError_base {
+}
+/**
+ * Durable suspected-edge persistence operations. `snapshot` pins the injected
+ * clock's now, never `Date.now()`; `train` applies the asymmetric rule — a
+ * hit gains five percent of the remaining headroom, a miss halves — to
+ * matching stored edges only, ignoring unknown pairs rather than creating
+ * them. Training retains at most {@link maxEvidenceEntries} newest evidence
+ * entries per edge.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Service {
+    readonly upsert: (edges: ReadonlyArray<Selection.SuspectedEdge>) => Effect.Effect<void, SelectionStoreError>;
+    readonly list: () => Effect.Effect<ReadonlyArray<Selection.SuspectedEdge>, SelectionStoreError>;
+    readonly snapshot: () => Effect.Effect<Selection.BeliefSnapshot, SelectionStoreError>;
+    readonly train: (observations: ReadonlyArray<TrainingObservation>) => Effect.Effect<void, SelectionStoreError>;
+}
+declare const SelectionStore_base: Context.ServiceClass<SelectionStore, "@smthrs/engine-store/SelectionStore", Service>;
+/**
+ * Service tag for the durable suspected-edge store.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class SelectionStore extends SelectionStore_base {
+}
+/**
+ * Maximum evidence entries retained for one suspected edge. Training drops
+ * the oldest entries after this bound and preserves the newest entries in
+ * observation order.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const maxEvidenceEntries = 128;
+/**
+ * Builds the SQL-backed suspected-edge store.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: Effect.Effect<Service, never, DurableWriter | SqlClient.SqlClient>;
+/**
+ * Provides the SQL-backed suspected-edge store.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<SelectionStore, never, DurableWriter | SqlClient.SqlClient>;
+export {};
+//# sourceMappingURL=SelectionStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionStore.d.ts","sourceRoot":"","sources":["../../src/SelectionStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAE9D,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC1D,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,2CAAmC,CAAA;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAC,IAAI,CAAA;AAEzD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,oFAIlC,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;;;;;;;;AAEzE;;;;;GAKG;AACH,qBAAa,mBAAoB,SAAQ,wBASxC;CAAG;AAEJ;;;;;;;;;;GAUG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,CACf,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,KAC1C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAA;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,EAAE,mBAAmB,CAAC,CAAA;IAC/F,QAAQ,CAAC,QAAQ,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAA;IACrF,QAAQ,CAAC,KAAK,EAAE,CACd,YAAY,EAAE,aAAa,CAAC,mBAAmB,CAAC,KAC7C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAA;CAC9C;;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,mBAEnC;CAAG;AA2FJ;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,GAAG,SAAS,CAAC,SAAS,CAoGlF,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,EAAE,aAAa,GAAG,SAAS,CAAC,SAAS,CAEnF,CAAA"}