@sweny-ai/core 0.1.177 → 0.1.178

package/dist/index.d.ts

@@ -27,8 +27,8 @@ export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, NODE_ON_FAIL, MCP_TRA
 export { consoleLogger } from "./types.js";
 export { execute, RouteEvaluationError } from "./executor.js";
 export type { ExecuteOptions } from "./executor.js";
-export { systemOneProvider, DecideError, gateVerdict, DECIDER_MIN_CONFIDENCE, DECIDER_MIN_MARGIN } from "./decider.js";
-export type { DecisionProvider, DeciderConfig, DeciderMode, DeciderRecord, SystemOneOptions } from "./decider.js";
+export { systemOneProvider } from "./decider.js";
+export type { DeciderConfig, DeciderOperatorConfig } from "./decider.js";
 export { BudgetGuard, describeOverrun, minLimits, toLimits } from "./budget.js";
 export type { Budget, BudgetOverrun, BudgetUnit, SpendLimits } from "./budget.js";
 export { resolveNodePermissions, buildNodePolicy } from "./node-policy.js";

package/dist/index.js

@@ -27,8 +27,8 @@ export { EVALUATOR_KINDS, EVAL_POLICIES, REQUIRES_ON_FAIL, NODE_ON_FAIL, MCP_TRA
 export { consoleLogger } from "./types.js";
 // Executor
 export { execute, RouteEvaluationError } from "./executor.js";
-// Decision models, shadow mode (#357)
-export { systemOneProvider, DecideError, gateVerdict, DECIDER_MIN_CONFIDENCE, DECIDER_MIN_MARGIN } from "./decider.js";
+// Decision models (#357): config types and the provider adapter only
+export { systemOneProvider } from "./decider.js";
 // Least-privilege nodes and safe outputs (#365)
 export { BudgetGuard, describeOverrun, minLimits, toLimits } from "./budget.js";
 export { resolveNodePermissions, buildNodePolicy } from "./node-policy.js";

package/dist/journal.d.ts

@@ -29,7 +29,7 @@
  *   output:intent    a write is about to be applied (idempotency key + tool)
  *   output:applied   the write returned (key + the ids it produced)
  *   node:end         final result of the visit and the write-stage counters
- *   route            the edge taken after the visit (null = the run ended)
+ *   route            the edge taken after the visit (null = the run ended), and the rung that chose it
  *   usage            spend of one agent attempt (cumulative; live while it runs, final when it returns)
  *   run:end          success | failed | crashed
  *
@@ -52,9 +52,10 @@
  * (the process died between the API call and the receipt) is looked up on the
  * provider by a marker embedded in the body before anything is re-sent.
  */
-import type { Logger, NodeResult, NodeUsage, Skill, Workflow } from "./types.js";
+import type { Logger, NodeResult, NodeUsage, RouteRung, Skill, Workflow } from "./types.js";
 import type { SafeOutputIntent, WriteStageState } from "./safe-outputs.js";
 import { type Spend } from "./budget.js";
+import type { DeciderCounters } from "./decider.js";
 /** v2: records are authenticated with a per-run HMAC key (v1 used a public checksum and is refused). */
 export declare const JOURNAL_SCHEMA_VERSION = 2;
 export declare const JOURNAL_DIR: string;
@@ -139,6 +140,10 @@ export interface RunStartRecord extends JournalRecord {
     sweny_version?: string;
     input: unknown;
     input_redacted: boolean;
+    decider?: {
+        mode: "on" | "off";
+        reason?: string;
+    };
 }
 export interface WriteStateSnapshot {
     counts: Array<[string, number]>;
@@ -218,6 +223,8 @@ export interface PlannedVisit {
     status?: NodeResult["status"];
     /** Route taken after the visit: a node id, null for run end, undefined when not journaled. */
     next?: string | null;
+    /** Who chose that route, when it was a decision (#357). */
+    rung?: RouteRung;
     /** Writes the checkpointed write stage already applied (receipts in the journal). */
     applied: number;
     /** Writes with an intent but no receipt: checked on the provider before anything is re-sent. */
@@ -243,6 +250,8 @@ export interface ResumePlan {
     receipts: Map<string, OutputRecord>;
     /** Spend every earlier attempt journaled: the run budget starts here on resume. */
     priorSpend: Spend;
+    /** The decider's mode at run start and its counters after the last journaled route (#357). */
+    decider?: JournalDeciderState;
 }
 /**
  * Check that the records are a sequence the executor can write: one run:start
@@ -281,6 +290,21 @@ export interface JournalBeginInfo {
     config: Record<string, string>;
     writeState: WriteStageState;
     harnessId?: string;
+    /** Whether the run's decider ran (#357), journaled so a resume keeps the same mode. */
+    decider?: {
+        mode: "on" | "off";
+        reason?: string;
+    };
+}
+/**
+ * The decider as an earlier attempt left it (#357): its mode at run start and
+ * the breaker / cap counters after the last journaled route. Cap and breaker
+ * are per logical run, so a resume continues them.
+ */
+export interface JournalDeciderState {
+    mode: "on" | "off";
+    reason?: string;
+    counters?: DeciderCounters;
 }
 export interface JournalCheckpoint {
     result: NodeResult;
@@ -292,6 +316,7 @@ export type JournalReplay = {
     kind: "complete";
     result: NodeResult;
     next?: string | null;
+    rung?: RouteRung;
 } | ({
     kind: "checkpoint";
 } & JournalCheckpoint);
@@ -308,7 +333,8 @@ export interface ExecutionJournal {
     /** The skill map the write stage applies through: write tools journaled and made idempotent. */
     wrapWrites(node: string, iteration: number, skills: Map<string, Skill>): Map<string, Skill>;
     nodeEnd(node: string, iteration: number, result: NodeResult, writeState: WriteStageState): void;
-    route(from: string, to: string | null): void;
+    /** The edge taken after a visit, and for a decision the rung that chose it (#357), so resume replays it. */
+    route(from: string, to: string | null, rung?: RouteRung, decider?: DeciderCounters): void;
     /**
      * Spend of one agent attempt, cumulative for the attempt: `final` when the
      * attempt returned, otherwise a live report (the journal may throttle those).
@@ -316,6 +342,8 @@ export interface ExecutionJournal {
     usage?(node: string, iteration: number, attempt: number, usage: NodeUsage, final: boolean): void;
     /** Spend earlier attempts of this run already journaled (resume); the run budget starts from it. */
     priorSpend?(): Spend | undefined;
+    /** The decider state earlier attempts of this run journaled (resume); undefined otherwise. */
+    deciderResume?(): JournalDeciderState | undefined;
 }
 /** Minimum gap between two live usage records of one attempt. Final reports are always written. */
 export declare const USAGE_JOURNAL_INTERVAL_MS = 2000;
@@ -389,11 +417,12 @@ export declare class RunJournal implements ExecutionJournal {
     private closeFd;
     private clean;
     begin(info: JournalBeginInfo): void;
+    deciderResume(): JournalDeciderState | undefined;
     replay(node: string, iteration: number): JournalReplay | undefined;
     nodeStart(node: string, iteration: number): void;
     checkpoint(node: string, iteration: number, cp: JournalCheckpoint): void;
     nodeEnd(node: string, iteration: number, result: NodeResult, writeState: WriteStageState): void;
-    route(from: string, to: string | null): void;
+    route(from: string, to: string | null, rung?: RouteRung, decider?: DeciderCounters): void;
     usage(node: string, iteration: number, attempt: number, usage: NodeUsage, final: boolean): void;
     priorSpend(): Spend | undefined;
     /** Close the run: `run:end`, then release the lock. Safe to call twice (one run:end). */

package/dist/journal.js

@@ -29,7 +29,7 @@
  *   output:intent    a write is about to be applied (idempotency key + tool)
  *   output:applied   the write returned (key + the ids it produced)
  *   node:end         final result of the visit and the write-stage counters
- *   route            the edge taken after the visit (null = the run ended)
+ *   route            the edge taken after the visit (null = the run ended), and the rung that chose it
  *   usage            spend of one agent attempt (cumulative; live while it runs, final when it returns)
  *   run:end          success | failed | crashed
  *
@@ -293,13 +293,15 @@ export function redact(value, secrets = []) {
             return v.map((x) => walk(x, depth + 1));
         if (v && typeof v === "object") {
             const out = {};
+            // defineProperty, not assignment: a key named `__proto__` stays a plain key.
+            const put = (k, x) => Object.defineProperty(out, k, { value: x, enumerable: true, writable: true, configurable: true });
             for (const [k, x] of Object.entries(v)) {
                 if (typeof x === "string" && isSecretKey(k) && x.length > 0) {
-                    out[k] = REDACTED;
+                    put(k, REDACTED);
                     redacted = true;
                 }
                 else if (x !== undefined && typeof x !== "function") {
-                    out[k] = walk(x, depth + 1);
+                    put(k, walk(x, depth + 1));
                 }
             }
             return out;
@@ -467,6 +469,13 @@ const RECORD_TYPES = new Set([
 const isPosInt = (v) => typeof v === "number" && Number.isInteger(v) && v > 0;
 const isName = (v) => typeof v === "string" && v.length > 0;
 const isAmount = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+const isRung = (v) => v === "expr" || v === "decider" || v === "agent";
+const isCount = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
+const isCounters = (v) => typeof v === "object" &&
+    v !== null &&
+    isCount(v.calls) &&
+    isCount(v.failures) &&
+    typeof v.open === "boolean";
 /**
  * Check that the records are a sequence the executor can write: one run:start
  * first; nothing but run:resume after run:end; a visit starts only where the
@@ -583,6 +592,10 @@ export function checkRecordSequence(records) {
                     bad(r, `routes from ${String(r.from)}, but the visit that ended is ${cur.node}`);
                 if (r.to !== null && !isName(r.to))
                     bad(r, "has no valid target");
+                if (r.rung !== undefined && !isRung(r.rung))
+                    bad(r, "has an unknown rung");
+                if (r.decider !== undefined && !isCounters(r.decider))
+                    bad(r, "has invalid decider counters");
                 cur.routed = true;
                 next = r.to;
                 break;
@@ -663,6 +676,7 @@ export function buildResumePlan(records) {
     const receipts = new Map();
     let attempts = 1;
     let lastStatus;
+    let deciderCounters;
     for (const r of records) {
         switch (r.type) {
             case "run:resume":
@@ -681,6 +695,7 @@ export function buildResumePlan(records) {
                     // Re-run of a visit an earlier attempt did not finish (or finished failed).
                     delete v.end;
                     delete v.next;
+                    delete v.rung;
                 }
                 break;
             }
@@ -699,8 +714,14 @@ export function buildResumePlan(records) {
             case "route": {
                 const from = r.from;
                 const v = [...order].reverse().find((x) => x.node === from);
-                if (v)
+                if (v) {
                     v.next = r.to ?? null;
+                    if (isRung(r.rung))
+                        v.rung = r.rung;
+                }
+                // Calls already made count even if the visit later re-runs.
+                if (isCounters(r.decider))
+                    deciderCounters = r.decider;
                 break;
             }
             case "output:intent":
@@ -733,6 +754,7 @@ export function buildResumePlan(records) {
                 action: "replay",
                 status: v.end.result.status,
                 next: v.next,
+                ...(v.rung ? { rung: v.rung } : {}),
                 applied,
                 unconfirmed,
             });
@@ -776,6 +798,9 @@ export function buildResumePlan(records) {
         intents,
         receipts,
         priorSpend: journaledSpend(records),
+        ...(start.decider
+            ? { decider: { ...start.decider, ...(deciderCounters ? { counters: { ...deciderCounters } } : {}) } }
+            : {}),
     };
 }
 /**
@@ -1153,8 +1178,12 @@ export class RunJournal {
             ...(this.opts.swenyVersion ? { sweny_version: this.opts.swenyVersion } : {}),
             input: input.value,
             input_redacted: input.redacted,
+            ...(info.decider ? { decider: info.decider } : {}),
         });
     }
+    deciderResume() {
+        return this.resume?.plan.decider;
+    }
     replay(node, iteration) {
         const plan = this.resume?.plan;
         if (!plan)
@@ -1172,6 +1201,7 @@ export class RunJournal {
                 kind: "complete",
                 result: structuredClone(end.result),
                 ...(visit.next !== undefined ? { next: visit.next } : {}),
+                ...(visit.rung ? { rung: visit.rung } : {}),
             };
         }
         if (visit.action === "write-stage") {
@@ -1209,8 +1239,8 @@ export class RunJournal {
             write_state: { counts: [...writeState.counts], total: writeState.total, seen: [...writeState.seen] },
         });
     }
-    route(from, to) {
-        this.append("route", { from, to });
+    route(from, to, rung, decider) {
+        this.append("route", { from, to, ...(rung ? { rung } : {}), ...(decider ? { decider } : {}) });
     }
     usage(node, iteration, attempt, usage, final) {
         const s = spendOf(usage);