patchwork-os 0.2.0-beta.9.canary.92 → 1.1.0-beta.1

package/dist/workers/shadowObserver.js

@@ -0,0 +1,203 @@
+import { categoriseHaltReason } from "../recipes/haltCategory.js";
+import { classifyActionClass } from "./actionClass.js";
+import { DEFAULT_GRADUATION_CONFIG, } from "./graduation.js";
+import { recommend } from "./shadowGate.js";
+import { ownsAction, ownsClassKey, priorFor, } from "./worker.js";
+import { WorkerLevelStore, } from "./workerLevelStore.js";
+/** Default durability window — a non-reversible success must survive this long
+ *  before it counts as earned trust. 24h is long enough to catch a revert /
+ *  close-as-junk / rollback, short enough that a genuinely-good action graduates
+ *  within a day. */
+export const DEFAULT_DURABILITY_WINDOW_MS = 24 * 60 * 60 * 1000;
+/**
+ * Durable-outcome label. `good = step.status:ok` is an OPTIMISTIC proxy: a PR
+ * that merged, an issue that filed — but a junk issue closed seconds later, or a
+ * commit reverted within the hour, "succeeded" at the moment yet is not earned
+ * trust. So a SUCCESS on a non-reversible (compensable/irreversible) action is
+ * "durable" — i.e. counts as evidence — only once it has survived the durability
+ * window. Reversible successes (undoable / re-runnable: reads, ledgered writes,
+ * local commits, CI) are always durable. Failures are unaffected (a failure is
+ * durable evidence of failure regardless of age).
+ *
+ * This only ever WITHHOLDS recent risky successes (reduces evidence → lower
+ * trust → more gating), so it never widens autonomy. See
+ * docs/worker-autonomy-policy-gate.md §3d.
+ */
+export function isDurableSuccess(reversibility, runAt, now, windowMs) {
+    if (reversibility === "reversible")
+        return true;
+    return runAt <= now - windowMs;
+}
+export function foldOutcome(step, runAt, opts) {
+    if (!step.tool)
+        return { fold: false };
+    if (step.status !== "ok")
+        return { fold: true, good: false };
+    // Success. Without a wall-clock, keep the prior status-only fold (back-compat).
+    if (opts.now === undefined)
+        return { fold: true, good: true };
+    const ac = classifyActionClass(step.tool);
+    // For a non-reversible filing, read the operator disposition up front (issue /
+    // PR URL). Reversible successes never consult the store — they are always durable.
+    const outcomeStore = ac.reversibility !== "reversible" ? opts.outcomeStore : undefined;
+    const url = outcomeStore && step.output && typeof step.output.url === "string"
+        ? step.output.url
+        : null;
+    const disposition = url ? (outcomeStore?.getDisposition(url) ?? null) : null;
+    // A human REJECTION demotes IMMEDIATELY. Junk is durable evidence of failure
+    // the moment it lands, so — like any outright failure (status ≠ ok above) — it
+    // must NOT sit withheld for the durability window ("demotion is instant", see
+    // trustLevel.ts). Checked BEFORE the window. Confirmed/unknown must NOT
+    // short-circuit the window: folding a still-provisional success early would
+    // WIDEN evidence, so this is junk-early only.
+    if (disposition === "junk")
+        return { fold: true, good: false };
+    if (!isDurableSuccess(ac.reversibility, runAt, opts.now, opts.windowMs))
+        return { fold: false }; // pending — survives the window before it earns trust
+    // Past the window: an unactioned filing (unknown / no record) is WITHHELD —
+    // unactioned ≠ correct (trust-by-neglect fix). Confirmed / no-url → good:true.
+    if (url && (disposition === "unknown" || disposition === null))
+        return { fold: false }; // withheld — not evidence
+    return { fold: true, good: true };
+}
+export class WorkerShadowObserver {
+    store;
+    cfg;
+    workers;
+    compare = new Map();
+    /** Wall-clock supplied by the I/O entry (the observer stays pure — no
+     *  Date.now). When set, durable-outcome labelling is active; when undefined,
+     *  the prior status-only behaviour is preserved (back-compat for pure tests). */
+    now;
+    durabilityWindowMs;
+    /** Optional outcome store — when present, junk issues flip good:false past
+     *  the durability window instead of counting as earned trust. */
+    outcomeStore;
+    constructor(workers, opts = {}) {
+        this.workers = workers;
+        this.store = opts.store ?? new WorkerLevelStore();
+        this.cfg = opts.cfg ?? DEFAULT_GRADUATION_CONFIG;
+        this.now = opts.now;
+        this.durabilityWindowMs =
+            opts.durabilityWindowMs ?? DEFAULT_DURABILITY_WINDOW_MS;
+        this.outcomeStore = opts.outcomeStore;
+    }
+    /**
+     * The populated level store. Exposed so the LIVE worker-autonomy gate
+     * (`workerGate.decideWorkerAction`) can read the same earned levels this
+     * observer derives from the run log — one source of truth for the dial and
+     * the gate. Read-only intent; callers must not mutate.
+     */
+    get levelStore() {
+        return this.store;
+    }
+    /** The worker whose recipe body is `recipeName`, if any. */
+    workerForRecipe(recipeName) {
+        return this.workers.find((w) => w.recipe === recipeName);
+    }
+    /** Attribute a tool call to its SOLE owning worker (ambiguous → skip). */
+    workerForAction(toolName, params) {
+        const ac = classifyActionClass(toolName, params);
+        const owners = this.workers.filter((w) => ownsAction(w, ac));
+        return owners.length === 1 ? owners[0] : undefined;
+    }
+    /** Feed a recipe run's step outcomes into the owning worker's dial. */
+    ingestRun(run) {
+        const worker = this.workerForRecipe(run.recipeName);
+        if (!worker)
+            return;
+        const prior = priorFor(worker);
+        for (const step of run.steps) {
+            if (!step.tool || step.status === "skipped")
+                continue; // skipped ≠ evidence
+            // L2: a step halted because a HUMAN rejected / let expire / cancelled the
+            // approval is a control decision, not a worker failure — counting it as
+            // `good: false` would demote the worker for every correct "not yet", so
+            // the gate could never self-clear. Skip it (non-evidence). Genuine tool
+            // errors still count.
+            if (step.status === "error" &&
+                categoriseHaltReason(step.haltReason) === "approval_rejected")
+                continue;
+            // Durable-outcome fold (shared with the backtest via foldOutcome): a recent
+            // SUCCESS on a non-reversible action is provisional, and past the window a
+            // junk filing flips good:false while an unknown/unactioned one is WITHHELD
+            // (trust-by-neglect fix). Only active when `now` was supplied; otherwise the
+            // prior status-only fold is used. Withholds evidence only → never widens.
+            const decision = foldOutcome(step, run.at, {
+                now: this.now,
+                windowMs: this.durabilityWindowMs,
+                outcomeStore: this.outcomeStore,
+            });
+            if (!decision.fold)
+                continue;
+            this.store.apply(worker.id, { toolName: step.tool, good: decision.good, at: run.at }, { prior, cfg: this.cfg });
+        }
+    }
+    /** Compare what the ramp WOULD recommend (given the dial as of now) against
+     * the gate's actual decision. Read-only — records agreement + divergences.
+     *
+     * Only worker-gate decisions (those with a recipeName) are counted. Plain
+     * Claude-session MCP tool approvals share the same ActivityLog event type
+     * but have no recipeName — including them would inflate divergences with
+     * calls the worker gate never saw. */
+    ingestDecision(d) {
+        if (!d.recipeName)
+            return;
+        const worker = this.workerForAction(d.toolName, d.params);
+        if (!worker)
+            return;
+        const rec = recommend(worker, d.toolName, d.params, this.store);
+        const rampBypass = rec.decision === "bypass";
+        const gateAllowed = d.decision === "allow";
+        // ramp "bypass" ↔ gate would not need to gate; ramp "queue" ↔ gate gates.
+        const agree = rampBypass === gateAllowed;
+        const slot = this.compare.get(worker.id) ?? {
+            compared: 0,
+            agreed: 0,
+            divergences: [],
+        };
+        slot.compared++;
+        if (agree) {
+            slot.agreed++;
+        }
+        else {
+            slot.divergences.push({
+                classKey: rec.classKey,
+                toolName: d.toolName,
+                ramp: rec.decision,
+                gate: d.decision,
+                at: d.at,
+                note: rampBypass
+                    ? `ramp would auto-run (${rec.reason}); gate still gated`
+                    : "ramp would gate; gate allowed",
+            });
+        }
+        this.compare.set(worker.id, slot);
+    }
+    report() {
+        return this.workers.map((w) => {
+            const c = this.compare.get(w.id) ?? {
+                compared: 0,
+                agreed: 0,
+                divergences: [],
+            };
+            return {
+                workerId: w.id,
+                name: w.name,
+                autonomyCeiling: w.autonomyCeiling,
+                // L3: flag rows for classes the worker performs but does NOT own — the
+                // dial shows accrued evidence there, but the live gate floors them to 0
+                // (a worker has no standing trust outside its `owns`). Without the flag
+                // the dial looks like earned autonomy that the gate silently ignores.
+                board: this.store
+                    .board(w.id)
+                    .map((r) => ({ ...r, owned: ownsClassKey(w, r.classKey) })),
+                events: this.store.events(w.id),
+                compared: c.compared,
+                agreed: c.agreed,
+                divergences: c.divergences,
+            };
+        });
+    }
+}
+//# sourceMappingURL=shadowObserver.js.map

package/dist/workers/shadowObserver.js.map

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

package/dist/workers/shadowReport.d.ts

@@ -0,0 +1,16 @@
+import type { GraduationConfig } from "./graduation.js";
+import type { OutcomeStore } from "./outcomeStore.js";
+import { type DecisionRecord, type RunRecord, type WorkerShadowReport } from "./shadowObserver.js";
+import type { WorkerManifest } from "./worker.js";
+/**
+ * Build the shadow report by feeding runs + decisions into the observer in
+ * timestamp order, so each ramp-vs-gate comparison sees the dial as it stood AT
+ * that moment (not the final state). Pure — the I/O entry (runWorkerShadow)
+ * supplies the records read from the real logs.
+ */
+export declare function buildShadowReport(workers: WorkerManifest[], runs: RunRecord[], decisions: DecisionRecord[], cfg?: GraduationConfig, opts?: {
+    now?: number;
+    durabilityWindowMs?: number;
+    outcomeStore?: OutcomeStore;
+}): WorkerShadowReport[];
+export declare function formatShadowReport(reports: WorkerShadowReport[]): string;

package/dist/workers/shadowReport.js

@@ -0,0 +1,61 @@
+import { WorkerShadowObserver, } from "./shadowObserver.js";
+/**
+ * Build the shadow report by feeding runs + decisions into the observer in
+ * timestamp order, so each ramp-vs-gate comparison sees the dial as it stood AT
+ * that moment (not the final state). Pure — the I/O entry (runWorkerShadow)
+ * supplies the records read from the real logs.
+ */
+export function buildShadowReport(workers, runs, decisions, cfg, opts = {}) {
+    const obs = new WorkerShadowObserver(workers, {
+        cfg,
+        ...(opts.now !== undefined && { now: opts.now }),
+        ...(opts.durabilityWindowMs !== undefined && {
+            durabilityWindowMs: opts.durabilityWindowMs,
+        }),
+        ...(opts.outcomeStore !== undefined && { outcomeStore: opts.outcomeStore }),
+    });
+    const merged = [
+        ...runs.map((r) => ({ at: r.at, run: r })),
+        ...decisions.map((d) => ({ at: d.at, dec: d })),
+    ].sort((a, b) => a.at - b.at);
+    for (const e of merged) {
+        if (e.run)
+            obs.ingestRun(e.run);
+        else if (e.dec)
+            obs.ingestDecision(e.dec);
+    }
+    return obs.report();
+}
+export function formatShadowReport(reports) {
+    const lines = [
+        "Worker trust dial — SHADOW (read-only; no live gate change)",
+        "",
+    ];
+    for (const r of reports) {
+        lines.push(`▸ ${r.name} [${r.workerId}]  ·  autonomy ceiling L${r.autonomyCeiling}`);
+        if (r.board.length === 0) {
+            lines.push("    (no attributed activity yet — dial fills as the worker runs)");
+        }
+        else {
+            for (const b of r.board) {
+                const capped = b.level > r.autonomyCeiling
+                    ? `  → operating L${r.autonomyCeiling} (ceiling)`
+                    : "";
+                // L3: a class the worker performs but doesn't own is floored to L0 by
+                // the gate regardless of the evidence shown here — flag it so the dial
+                // isn't read as earned autonomy the gate will honour.
+                const notOwned = b.owned ? "" : "  ⚠ NOT OWNED — gate floors to L0";
+                lines.push(`    ${b.classKey.padEnd(36)} earned L${b.level}${capped}  ·  ${b.observations} obs  ·  ${(b.mean * 100).toFixed(0)}% mean${notOwned}`);
+            }
+        }
+        if (r.compared > 0) {
+            lines.push(`    ramp vs gate: ${r.agreed}/${r.compared} agree · ${r.divergences.length} divergence(s)`);
+            for (const d of r.divergences.slice(0, 5)) {
+                lines.push(`      ⚠ ${d.toolName} — ${d.note}`);
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=shadowReport.js.map

package/dist/workers/shadowReport.js.map

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

package/dist/workers/shadowRun.d.ts

@@ -0,0 +1,38 @@
+import { type GraduationConfig, type Outcome } from "./graduation.js";
+import { type WorkerManifest } from "./worker.js";
+import { type AuditEvent, type BoardRow, WorkerLevelStore } from "./workerLevelStore.js";
+/**
+ * Replay an outcome sequence for a worker and capture the per-step dial
+ * trajectory. This is the cheapest test of the evidence-latency risk: it shows,
+ * deterministically, how many real observations (and how much wall-clock) a
+ * worker needs to climb each class — and how one catastrophic outcome demotes
+ * it in a single step. No model calls, no live gate — pure replay.
+ */
+export interface TrajectoryStep {
+    index: number;
+    at: number;
+    toolName: string;
+    good: boolean;
+    classKey: string;
+    level: number;
+    changed: "promote" | "demote" | null;
+}
+export interface ShadowRunResult {
+    workerId: string;
+    trajectory: TrajectoryStep[];
+    board: BoardRow[];
+    events: AuditEvent[];
+    store: WorkerLevelStore;
+}
+export declare function shadowRun(worker: WorkerManifest, outcomes: Outcome[], opts?: {
+    cfg?: GraduationConfig;
+    store?: WorkerLevelStore;
+}): ShadowRunResult;
+/** First trajectory step where `classKey` reached at least `level`. */
+export declare function firstReached(result: ShadowRunResult, classKey: string, level: number): TrajectoryStep | undefined;
+/** Build a steady cadence of same-tool outcomes spaced `intervalMs` apart. */
+export declare function cadence(toolName: string, count: number, opts?: {
+    startAt?: number;
+    intervalMs?: number;
+    good?: boolean;
+}): Outcome[];

package/dist/workers/shadowRun.js

@@ -0,0 +1,44 @@
+import { DEFAULT_GRADUATION_CONFIG, } from "./graduation.js";
+import { priorFor } from "./worker.js";
+import { WorkerLevelStore, } from "./workerLevelStore.js";
+export function shadowRun(worker, outcomes, opts = {}) {
+    const store = opts.store ?? new WorkerLevelStore();
+    const cfg = opts.cfg ?? DEFAULT_GRADUATION_CONFIG;
+    const prior = priorFor(worker);
+    const trajectory = [];
+    outcomes.forEach((o, index) => {
+        const r = store.apply(worker.id, o, { prior, cfg });
+        trajectory.push({
+            index,
+            at: o.at,
+            toolName: o.toolName,
+            good: o.good,
+            classKey: r.classKey,
+            level: r.state.level,
+            changed: r.event?.type ?? null,
+        });
+    });
+    return {
+        workerId: worker.id,
+        trajectory,
+        board: store.board(worker.id),
+        events: store.events(worker.id),
+        store,
+    };
+}
+/** First trajectory step where `classKey` reached at least `level`. */
+export function firstReached(result, classKey, level) {
+    return result.trajectory.find((s) => s.classKey === classKey && s.level >= level);
+}
+/** Build a steady cadence of same-tool outcomes spaced `intervalMs` apart. */
+export function cadence(toolName, count, opts = {}) {
+    const start = opts.startAt ?? 0;
+    const interval = opts.intervalMs ?? 6 * 60 * 60 * 1000; // 6h
+    const good = opts.good ?? true;
+    return Array.from({ length: count }, (_, i) => ({
+        toolName,
+        good,
+        at: start + i * interval,
+    }));
+}
+//# sourceMappingURL=shadowRun.js.map

package/dist/workers/shadowRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowRun.js","sourceRoot":"","sources":["../../src/workers/shadowRun.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,GAG1B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAuB,MAAM,aAAa,CAAC;AAC5D,OAAO,EAGL,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AA4B/B,MAAM,UAAU,SAAS,CACvB,MAAsB,EACtB,QAAmB,EACnB,OAA6D,EAAE;IAE/D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,IAAI,IAAI,gBAAgB,EAAE,CAAC;IACnD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,yBAAyB,CAAC;IAClD,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/B,MAAM,UAAU,GAAqB,EAAE,CAAC;IACxC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE;QAC5B,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QACpD,UAAU,CAAC,IAAI,CAAC;YACd,KAAK;YACL,EAAE,EAAE,CAAC,CAAC,EAAE;YACR,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,IAAI,EAAE,CAAC,CAAC,IAAI;YACZ,QAAQ,EAAE,CAAC,CAAC,QAAQ;YACpB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK;YACpB,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,IAAI,IAAI;SAC/B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IACH,OAAO;QACL,QAAQ,EAAE,MAAM,CAAC,EAAE;QACnB,UAAU;QACV,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QAC/B,KAAK;KACN,CAAC;AACJ,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,YAAY,CAC1B,MAAuB,EACvB,QAAgB,EAChB,KAAa;IAEb,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAC3B,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,IAAI,CAAC,CAAC,KAAK,IAAI,KAAK,CACnD,CAAC;AACJ,CAAC;AAED,8EAA8E;AAC9E,MAAM,UAAU,OAAO,CACrB,QAAgB,EAChB,KAAa,EACb,OAAkE,EAAE;IAEpE,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;IAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,KAAK;IAC7D,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC;IAC/B,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC9C,QAAQ;QACR,IAAI;QACJ,EAAE,EAAE,KAAK,GAAG,CAAC,GAAG,QAAQ;KACzB,CAAC,CAAC,CAAC;AACN,CAAC"}

package/dist/workers/trustLevel.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Bayesian trust model for a single (worker × action-class) pair.
+ *
+ * Reliability `p` (the probability that an action of this class is "good") is a
+ * Beta(α, β) posterior. The discrete autonomy rung L0–L4 is a threshold
+ * crossing of the posterior's LOWER confidence bound, not its mean. Using the
+ * lower bound is what makes the ramp behave correctly:
+ *   - cold-start floors automatically: a fresh/wide posterior has a low bound
+ *     even if its mean is optimistic, so a worker (or a marketplace prior) can't
+ *     start trusted — uncertainty must collapse on local evidence first;
+ *   - climbing is slow: the bound only rises as the mean rises AND variance
+ *     shrinks, i.e. with sustained evidence;
+ *   - demotion is instant: one high-weight failure spikes β, the mean drops and
+ *     the bound craters in a single step.
+ *
+ * Asymmetry ("slow up, instant down") is therefore information, not a tuned
+ * rule — it falls out of weighting failures by blast radius (see actionClass).
+ */
+export interface Posterior {
+    readonly alpha: number;
+    readonly beta: number;
+}
+/** Uniform prior — maximally uncertain, no shipped competence. */
+export declare const DEFAULT_PRIOR: Posterior;
+/**
+ * Build a prior from a competence claim: a mean reliability + a strength
+ * (pseudo-count). Low strength = wide uncertainty = the bound stays low until
+ * local evidence accumulates. This is how a marketplace worker ships
+ * competence (a mean) without shipping trust (the bound only tightens on the
+ * operator's own data). Strength is capped low on purpose.
+ */
+export declare function priorFromCompetence(mean: number, strength: number): Posterior;
+export declare function posteriorMean(p: Posterior): number;
+export declare function posteriorStddev(p: Posterior): number;
+/** Lower confidence bound: mean − k·σ, clamped to [0, 1]. The level reads off
+ * THIS, not the mean. */
+export declare function lowerConfidenceBound(p: Posterior, k?: number): number;
+/** Apply one outcome. A good outcome adds to α, a bad one to β, scaled by the
+ * blast-weighted evidence weight from actionClass.outcomeWeight. */
+export declare function applyOutcome(p: Posterior, good: boolean, weight: number): Posterior;
+/** Total evidence accumulated relative to the prior (pseudo-observations). */
+export declare function evidenceCount(p: Posterior, prior: Posterior): number;
+export type TrustLevel = 0 | 1 | 2 | 3 | 4;
+/** LCB → rung. Tunable; conservative by default. */
+export declare const DEFAULT_THRESHOLDS: ReadonlyArray<{
+    min: number;
+    level: TrustLevel;
+}>;
+export interface LevelOpts {
+    k?: number;
+    /** Min evidence before a class may exceed L1 (novel-class floor). */
+    minEvidenceForGraduation?: number;
+    /** Rungs reachable for this class (irreversible classes omit L2/L3). */
+    reachable?: number[];
+    thresholds?: ReadonlyArray<{
+        min: number;
+        level: TrustLevel;
+    }>;
+}
+export interface LevelResult {
+    level: TrustLevel;
+    /** Level before the novel-floor + reachability clamps (for diagnostics). */
+    rawLevel: TrustLevel;
+    lcb: number;
+    mean: number;
+    evidence: number;
+}
+/**
+ * Map a posterior to a discrete rung, applying:
+ *  1. LCB → raw level via thresholds.
+ *  2. Novel-class floor: below the effective evidence minimum, cap at L1.
+ *     "Effective evidence" = real observations + prior pseudo-count beyond the
+ *     uniform baseline (prior.alpha + prior.beta − 2). A strong operator prior
+ *     (strength 8 → contributes 6) reduces the real observations needed before
+ *     graduation is permitted; the default uniform prior contributes 0 so
+ *     existing behaviour is unchanged. No class can skip the floor entirely via
+ *     prior alone — the prior's LCB is still too wide without real data.
+ *  3. Reachability clamp: drop to the highest reachable rung ≤ the computed one,
+ *     so an irreversible class climbing through "would-be L2/L3" stays at L1
+ *     until it actually clears the L4 bar.
+ */
+export declare function levelFromPosterior(p: Posterior, prior: Posterior, opts?: LevelOpts): LevelResult;

package/dist/workers/trustLevel.js

@@ -0,0 +1,100 @@
+/**
+ * Bayesian trust model for a single (worker × action-class) pair.
+ *
+ * Reliability `p` (the probability that an action of this class is "good") is a
+ * Beta(α, β) posterior. The discrete autonomy rung L0–L4 is a threshold
+ * crossing of the posterior's LOWER confidence bound, not its mean. Using the
+ * lower bound is what makes the ramp behave correctly:
+ *   - cold-start floors automatically: a fresh/wide posterior has a low bound
+ *     even if its mean is optimistic, so a worker (or a marketplace prior) can't
+ *     start trusted — uncertainty must collapse on local evidence first;
+ *   - climbing is slow: the bound only rises as the mean rises AND variance
+ *     shrinks, i.e. with sustained evidence;
+ *   - demotion is instant: one high-weight failure spikes β, the mean drops and
+ *     the bound craters in a single step.
+ *
+ * Asymmetry ("slow up, instant down") is therefore information, not a tuned
+ * rule — it falls out of weighting failures by blast radius (see actionClass).
+ */
+/** Uniform prior — maximally uncertain, no shipped competence. */
+export const DEFAULT_PRIOR = { alpha: 1, beta: 1 };
+/**
+ * Build a prior from a competence claim: a mean reliability + a strength
+ * (pseudo-count). Low strength = wide uncertainty = the bound stays low until
+ * local evidence accumulates. This is how a marketplace worker ships
+ * competence (a mean) without shipping trust (the bound only tightens on the
+ * operator's own data). Strength is capped low on purpose.
+ */
+export function priorFromCompetence(mean, strength) {
+    const m = Math.min(0.99, Math.max(0.01, mean));
+    const s = Math.min(8, Math.max(0.5, strength));
+    return { alpha: m * s, beta: (1 - m) * s };
+}
+export function posteriorMean(p) {
+    return p.alpha / (p.alpha + p.beta);
+}
+export function posteriorStddev(p) {
+    const n = p.alpha + p.beta;
+    return Math.sqrt((p.alpha * p.beta) / (n * n * (n + 1)));
+}
+/** Lower confidence bound: mean − k·σ, clamped to [0, 1]. The level reads off
+ * THIS, not the mean. */
+export function lowerConfidenceBound(p, k = 1.5) {
+    return Math.max(0, Math.min(1, posteriorMean(p) - k * posteriorStddev(p)));
+}
+/** Apply one outcome. A good outcome adds to α, a bad one to β, scaled by the
+ * blast-weighted evidence weight from actionClass.outcomeWeight. */
+export function applyOutcome(p, good, weight) {
+    return good
+        ? { alpha: p.alpha + weight, beta: p.beta }
+        : { alpha: p.alpha, beta: p.beta + weight };
+}
+/** Total evidence accumulated relative to the prior (pseudo-observations). */
+export function evidenceCount(p, prior) {
+    return p.alpha + p.beta - (prior.alpha + prior.beta);
+}
+/** LCB → rung. Tunable; conservative by default. */
+export const DEFAULT_THRESHOLDS = [
+    { min: 0.95, level: 4 },
+    { min: 0.85, level: 3 },
+    { min: 0.7, level: 2 },
+    { min: 0.5, level: 1 },
+    { min: 0, level: 0 },
+];
+/**
+ * Map a posterior to a discrete rung, applying:
+ *  1. LCB → raw level via thresholds.
+ *  2. Novel-class floor: below the effective evidence minimum, cap at L1.
+ *     "Effective evidence" = real observations + prior pseudo-count beyond the
+ *     uniform baseline (prior.alpha + prior.beta − 2). A strong operator prior
+ *     (strength 8 → contributes 6) reduces the real observations needed before
+ *     graduation is permitted; the default uniform prior contributes 0 so
+ *     existing behaviour is unchanged. No class can skip the floor entirely via
+ *     prior alone — the prior's LCB is still too wide without real data.
+ *  3. Reachability clamp: drop to the highest reachable rung ≤ the computed one,
+ *     so an irreversible class climbing through "would-be L2/L3" stays at L1
+ *     until it actually clears the L4 bar.
+ */
+export function levelFromPosterior(p, prior, opts = {}) {
+    const k = opts.k ?? 1.5;
+    const minEvidence = opts.minEvidenceForGraduation ?? 10;
+    const reachable = opts.reachable ?? [0, 1, 2, 3, 4];
+    const thresholds = opts.thresholds ?? DEFAULT_THRESHOLDS;
+    const lcb = lowerConfidenceBound(p, k);
+    const mean = posteriorMean(p);
+    const evidence = evidenceCount(p, prior);
+    const rawLevel = thresholds.find((t) => lcb >= t.min)?.level ?? 0;
+    let level = rawLevel;
+    // Novel-class floor: prior pseudo-count beyond the uniform baseline counts
+    // toward the evidence minimum, reducing cold-start latency for operator-
+    // configured workers without letting the prior alone bypass the floor.
+    const priorContribution = Math.max(0, prior.alpha + prior.beta - 2);
+    const effectiveEvidence = evidence + priorContribution;
+    if (effectiveEvidence < minEvidence && level > 1)
+        level = 1;
+    // Reachability clamp (highest reachable rung ≤ level).
+    const allowed = reachable.filter((r) => r <= level);
+    level = (allowed.length ? Math.max(...allowed) : 0);
+    return { level, rawLevel, lcb, mean, evidence };
+}
+//# sourceMappingURL=trustLevel.js.map

package/dist/workers/trustLevel.js.map

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

package/dist/workers/worker.d.ts

@@ -0,0 +1,49 @@
+import type { ActionClass } from "./actionClass.js";
+import { type Posterior, type TrustLevel } from "./trustLevel.js";
+export interface WorkerCompetence {
+    /** Claimed reliability mean (0–1) — a competence claim, not trust. */
+    mean: number;
+    /** Prior strength (pseudo-count); capped low so local evidence dominates. */
+    strength: number;
+}
+export interface WorkerManifest {
+    id: string;
+    name: string;
+    responsibilities: string[];
+    /** Recipe name that forms this worker's body (its triggers + steps). */
+    recipe?: string;
+    /**
+     * Action-classes this worker is responsible for. Each pattern matches a
+     * class by its domain, or by an exact/prefix class-key match
+     * (`vcs-local` matches `vcs-local:*`; `fs-write:reversible:medium` is exact).
+     */
+    owns: string[];
+    /**
+     * Policy/regulatory cap on the max ramp level this worker may EVER reach,
+     * independent of earned track record — the schema encoding of the
+     * autonomy-tolerance axis. The dial still shows *earned* level; the gate
+     * operates at min(earned, ceiling). Note: ceiling=2 is PERMISSIVE for
+     * compensable classes (they auto-allow at L2), not conservative — use
+     * ceiling=1 to keep compensable actions gated on a new or restricted worker.
+     */
+    autonomyCeiling: TrustLevel;
+    /** Optional shipped competence → the per-class prior. */
+    competence?: WorkerCompetence;
+    /** Free-form sector tag (drives default ceilings / reporting). */
+    sector?: string;
+}
+export declare class WorkerParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseWorker(raw: unknown): WorkerManifest;
+/** The per-class trust prior for a worker (its shipped competence, or uniform). */
+export declare function priorFor(worker: WorkerManifest): Posterior;
+/** Whether a worker is responsible for a given action-class. A pattern matches
+ * the class domain, an exact key, or a key prefix. Empty `owns` ⇒ owns nothing. */
+export declare function ownsAction(worker: WorkerManifest, ac: ActionClass): boolean;
+/**
+ * Ownership check against a raw class key (`domain:reversibility:blastTier`),
+ * for callers that have a board row's `classKey` but not a full ActionClass
+ * (e.g. the dial). Mirrors `ownsAction`: the domain is the key's first segment.
+ */
+export declare function ownsClassKey(worker: WorkerManifest, classKey: string): boolean;