@personaxis/core 0.11.0

package/dist/tools/registry.js

@@ -0,0 +1,162 @@
+/**
+ * Tool registry (G1) — the governed agent's action vocabulary.
+ *
+ * Each tool declares: a JSON-Schema for its args (used both for native
+ * function-calling and the constrained-JSON fallback), a `gate` that returns a
+ * sandbox verdict (allow | ask | deny) WITHOUT side effects, and an `execute`
+ * that performs the action and returns a text observation to feed back to the
+ * model. The agent loop owns the policy and only calls `execute` after the gate
+ * (and, for `ask`, the human) approves.
+ */
+import { evaluateCommand, evaluateFileWrite, pathEscapesWorkspace, } from "../sandbox.js";
+import { executeCommand, executeFileEdit, executeFileWrite, listDirSafe, readFileSafe, } from "./exec.js";
+/**
+ * FR.7: validate args against the tool's declared JSON Schema (required keys +
+ * primitive types — the registry's schemas are flat by design). Returns the
+ * problems found; empty = valid. Runs BEFORE the gate, so a malformed call is
+ * an input error, never a policy question.
+ */
+export function validateToolArgs(spec, args) {
+    const problems = [];
+    const schema = spec.parameters;
+    for (const k of schema.required ?? []) {
+        if (!(k in args))
+            problems.push(`missing required arg '${k}'`);
+    }
+    for (const [k, v] of Object.entries(args)) {
+        const prop = schema.properties?.[k];
+        if (!prop) {
+            if (schema.additionalProperties === false)
+                problems.push(`unknown arg '${k}'`);
+            continue;
+        }
+        if (prop.type && typeof v !== prop.type) {
+            problems.push(`arg '${k}' must be ${prop.type}, got ${typeof v}`);
+        }
+    }
+    return problems;
+}
+const READ_CLASS = { writesFiles: false, network: false, destructive: false, escapesWorkspace: false };
+/** Reads are allowed within the workspace; escaping it needs approval. */
+function readGate(path, policy) {
+    if (policy.sandbox === "danger-full-access") {
+        return { decision: "allow", reason: "full access", class: READ_CLASS };
+    }
+    const escapes = pathEscapesWorkspace(path, policy.workspaceRoot);
+    return escapes
+        ? { decision: "ask", reason: "read escapes the workspace", class: { ...READ_CLASS, escapesWorkspace: true } }
+        : { decision: "allow", reason: "in-workspace read", class: READ_CLASS };
+}
+const str = (a, k) => (typeof a[k] === "string" ? a[k] : "");
+export const TOOLS = [
+    {
+        name: "run_command",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+        description: "Run a shell command in the workspace and return its stdout/stderr. Use the command appropriate to the host OS (provided in context).",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["command"],
+            properties: { command: { type: "string", description: "The exact shell command to run." } },
+        },
+        gate: (args, policy) => evaluateCommand(str(args, "command"), policy),
+        execute: async (args, policy) => {
+            const r = await executeCommand(str(args, "command"), policy);
+            const parts = [`exit_code: ${r.code}${r.timedOut ? " (timed out)" : ""}`];
+            if (r.stdout.trim())
+                parts.push(`stdout:\n${r.stdout.trim()}`);
+            if (r.stderr.trim())
+                parts.push(`stderr:\n${r.stderr.trim()}`);
+            if (r.truncated)
+                parts.push("[output truncated]");
+            return parts.join("\n");
+        },
+    },
+    {
+        name: "read_file",
+        isReadOnly: true,
+        isConcurrencySafe: true,
+        description: "Read a UTF-8 text file relative to the workspace root.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path"],
+            properties: { path: { type: "string" } },
+        },
+        gate: (args, policy) => readGate(str(args, "path"), policy),
+        execute: async (args, policy) => {
+            const r = readFileSafe(str(args, "path"), policy);
+            return r.ok ? `${r.path}:\n${r.content ?? ""}` : `error: ${r.error}`;
+        },
+    },
+    {
+        name: "list_dir",
+        isReadOnly: true,
+        isConcurrencySafe: true,
+        description: "List the entries of a directory relative to the workspace root.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path"],
+            properties: { path: { type: "string" } },
+        },
+        gate: (args, policy) => readGate(str(args, "path"), policy),
+        execute: async (args, policy) => {
+            const r = listDirSafe(str(args, "path"), policy);
+            return r.ok ? `${r.path}:\n${r.content ?? "(empty)"}` : `error: ${r.error}`;
+        },
+    },
+    {
+        name: "write_file",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+        description: "Create or overwrite a text file (relative to the workspace root) with the given content.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path", "content"],
+            properties: { path: { type: "string" }, content: { type: "string" } },
+        },
+        gate: (args, policy) => evaluateFileWrite(str(args, "path"), policy),
+        execute: async (args, policy) => {
+            const r = executeFileWrite(str(args, "path"), str(args, "content"), policy);
+            return r.ok ? `wrote ${r.bytes} bytes to ${r.path}` : `error: ${r.error}`;
+        },
+    },
+    {
+        name: "edit_file",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+        description: "Replace the first occurrence of `find` with `replace` in an existing file.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["path", "find", "replace"],
+            properties: { path: { type: "string" }, find: { type: "string" }, replace: { type: "string" } },
+        },
+        gate: (args, policy) => evaluateFileWrite(str(args, "path"), policy),
+        execute: async (args, policy) => {
+            const r = executeFileEdit(str(args, "path"), str(args, "find"), str(args, "replace"), policy);
+            return r.ok ? `edited ${r.path}` : `error: ${r.error}`;
+        },
+    },
+    {
+        name: "finish",
+        isReadOnly: true,
+        isConcurrencySafe: true,
+        description: "Call this when the task is complete. Provide a short summary of what was done.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["summary"],
+            properties: { summary: { type: "string" } },
+        },
+        gate: () => ({ decision: "allow", reason: "finish", class: READ_CLASS }),
+        execute: async (args) => str(args, "summary"),
+    },
+];
+export const FINISH_TOOL = "finish";
+export function toolByName(name) {
+    return TOOLS.find((t) => t.name === name);
+}

package/dist/trace.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Observability / causal trace (v0.9 — spec `observability`).
+ *
+ * The engine already produces the raw material of a great trace: every step of
+ * the governed loops is an auditable event on the EventBus, and every state change
+ * is in the hash-chained mutation_log. 2026 production-agent practice (Braintrust /
+ * Arize / Microsoft Foundry) is unanimous that observability must be *causal
+ * tracing*, not response logging, and exportable to standard tooling. So a Tracer
+ * subscribes to a bus and serializes spans two ways:
+ *   - native JSONL (line-delimited, diff-able, dependency-free)
+ *   - OTLP-JSON (OpenTelemetry-compatible; plugs into Braintrust/Arize/Foundry)
+ *
+ * Secrets are redacted per `observability.redact` before anything is written.
+ */
+import { EventBus } from "./events.js";
+export type TraceFormat = "jsonl" | "otlp" | "both" | "off";
+export interface ObservabilityConfig {
+    trace: TraceFormat;
+    traceDir: string;
+    redact: string[];
+    sampleRate: number;
+}
+export declare const DEFAULT_OBSERVABILITY: ObservabilityConfig;
+export declare function readObservability(frontmatter: Record<string, unknown>): ObservabilityConfig;
+export interface TraceSpan {
+    /** ISO timestamp. */
+    ts: string;
+    /** Milliseconds since trace start. */
+    t_ms: number;
+    /** Monotonic index. */
+    seq: number;
+    /** Event type (span name). */
+    type: string;
+    /** Redacted event payload (everything except `type`). */
+    data: Record<string, unknown>;
+}
+/** Subscribes to a bus and records redacted spans; exports JSONL + OTLP. */
+export declare class Tracer {
+    private readonly bus;
+    private readonly cfg;
+    private readonly spans;
+    private readonly start;
+    private seq;
+    private readonly redactors;
+    private readonly off;
+    constructor(bus: EventBus, cfg?: ObservabilityConfig);
+    private record;
+    /** Detach from the bus. */
+    stop(): void;
+    getSpans(): TraceSpan[];
+    toJSONL(): string;
+    /** OpenTelemetry OTLP/JSON (trace) shape — point spans (start == end). */
+    toOTLP(): unknown;
+    /**
+     * Write the configured trace formats. `target` is a persona path or a directory;
+     * files land under `<target dir>/<traceDir>/trace-<ts>.{jsonl,otlp.json}`.
+     */
+    write(target: string, formatOverride?: TraceFormat): {
+        paths: string[];
+    };
+}
+/** Parse a native JSONL trace file's text into spans (for the viewer). */
+export declare function parseTraceJSONL(text: string): TraceSpan[];

package/dist/trace.js

@@ -0,0 +1,162 @@
+/**
+ * Observability / causal trace (v0.9 — spec `observability`).
+ *
+ * The engine already produces the raw material of a great trace: every step of
+ * the governed loops is an auditable event on the EventBus, and every state change
+ * is in the hash-chained mutation_log. 2026 production-agent practice (Braintrust /
+ * Arize / Microsoft Foundry) is unanimous that observability must be *causal
+ * tracing*, not response logging, and exportable to standard tooling. So a Tracer
+ * subscribes to a bus and serializes spans two ways:
+ *   - native JSONL (line-delimited, diff-able, dependency-free)
+ *   - OTLP-JSON (OpenTelemetry-compatible; plugs into Braintrust/Arize/Foundry)
+ *
+ * Secrets are redacted per `observability.redact` before anything is written.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+export const DEFAULT_OBSERVABILITY = {
+    trace: "off",
+    traceDir: "./traces",
+    redact: [],
+    sampleRate: 1,
+};
+export function readObservability(frontmatter) {
+    const o = frontmatter.observability;
+    if (!o)
+        return { ...DEFAULT_OBSERVABILITY };
+    const trace = o.trace === "jsonl" || o.trace === "otlp" || o.trace === "both" ? o.trace : "off";
+    return {
+        trace,
+        traceDir: typeof o.trace_dir === "string" ? o.trace_dir : DEFAULT_OBSERVABILITY.traceDir,
+        redact: Array.isArray(o.redact) ? o.redact.filter((r) => typeof r === "string") : [],
+        sampleRate: typeof o.sample_rate === "number" && o.sample_rate >= 0 && o.sample_rate <= 1 ? o.sample_rate : 1,
+    };
+}
+function compileRedactors(patterns) {
+    return patterns
+        .map((raw) => {
+        // JS has no inline-flag groups like (?i); strip a leading one (we already
+        // compile case-insensitive) so specs written with (?i)/(?im) still work.
+        const p = raw.replace(/^\(\?[a-z]+\)/i, "");
+        try {
+            return new RegExp(p, "gi");
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((r) => r !== null);
+}
+function redactValue(value, redactors) {
+    if (typeof value === "string") {
+        let s = value;
+        for (const r of redactors)
+            s = s.replace(r, "[redacted]");
+        return s;
+    }
+    if (Array.isArray(value))
+        return value.map((v) => redactValue(v, redactors));
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = redactValue(v, redactors);
+        return out;
+    }
+    return value;
+}
+/** Subscribes to a bus and records redacted spans; exports JSONL + OTLP. */
+export class Tracer {
+    bus;
+    cfg;
+    spans = [];
+    start = Date.now();
+    seq = 0;
+    redactors;
+    off;
+    constructor(bus, cfg = DEFAULT_OBSERVABILITY) {
+        this.bus = bus;
+        this.cfg = cfg;
+        this.redactors = compileRedactors(cfg.redact);
+        this.off = bus.on((e) => this.record(e));
+    }
+    record(e) {
+        if (this.cfg.sampleRate < 1 && Math.random() > this.cfg.sampleRate)
+            return;
+        const { type, ...rest } = e;
+        this.spans.push({
+            ts: new Date().toISOString(),
+            t_ms: Date.now() - this.start,
+            seq: this.seq++,
+            type,
+            data: redactValue(rest, this.redactors),
+        });
+    }
+    /** Detach from the bus. */
+    stop() {
+        this.off();
+    }
+    getSpans() {
+        return this.spans;
+    }
+    toJSONL() {
+        return this.spans.map((s) => JSON.stringify(s)).join("\n") + (this.spans.length ? "\n" : "");
+    }
+    /** OpenTelemetry OTLP/JSON (trace) shape — point spans (start == end). */
+    toOTLP() {
+        const toNano = (ms) => String((this.start + ms) * 1_000_000);
+        return {
+            resourceSpans: [
+                {
+                    resource: { attributes: [{ key: "service.name", value: { stringValue: "personaxis" } }] },
+                    scopeSpans: [
+                        {
+                            scope: { name: "personaxis.loop" },
+                            spans: this.spans.map((s) => ({
+                                name: s.type,
+                                startTimeUnixNano: toNano(s.t_ms),
+                                endTimeUnixNano: toNano(s.t_ms),
+                                attributes: Object.entries(s.data).map(([k, v]) => ({
+                                    key: k,
+                                    value: { stringValue: typeof v === "string" ? v : JSON.stringify(v) },
+                                })),
+                            })),
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    /**
+     * Write the configured trace formats. `target` is a persona path or a directory;
+     * files land under `<target dir>/<traceDir>/trace-<ts>.{jsonl,otlp.json}`.
+     */
+    write(target, formatOverride) {
+        const fmt = formatOverride ?? this.cfg.trace;
+        if (fmt === "off")
+            return { paths: [] };
+        const baseDir = resolve(dirname(target), this.cfg.traceDir);
+        mkdirSync(baseDir, { recursive: true });
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const paths = [];
+        if (fmt === "jsonl" || fmt === "both") {
+            const p = join(baseDir, `trace-${stamp}.jsonl`);
+            writeFileSync(p, this.toJSONL(), "utf-8");
+            paths.push(p);
+        }
+        if (fmt === "otlp" || fmt === "both") {
+            const p = join(baseDir, `trace-${stamp}.otlp.json`);
+            writeFileSync(p, JSON.stringify(this.toOTLP(), null, 2), "utf-8");
+            paths.push(p);
+        }
+        for (const p of paths)
+            this.bus.emit({ type: "trace-exported", format: p.endsWith(".jsonl") ? "jsonl" : "otlp", path: p, spanCount: this.spans.length });
+        return { paths };
+    }
+}
+/** Parse a native JSONL trace file's text into spans (for the viewer). */
+export function parseTraceJSONL(text) {
+    return text
+        .split("\n")
+        .filter((l) => l.trim().length > 0)
+        .map((l) => JSON.parse(l));
+}

package/dist/verification.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Objective verification (v0.9 — spec `verification`): the maker≠checker split.
+ *
+ * The loop-engineering research is blunt: the #1 reason loops fail is "a second
+ * agent asked to review without an objective gate — two optimists agreeing", and
+ * "the model that wrote the code is too nice grading its own homework". So the
+ * agent that did the work NEVER decides done; an INDEPENDENT verifier does, and
+ * where possible it is deterministic (a command's exit code, a predicate) rather
+ * than an opinion. Four gate types cover coding AND non-coding domains:
+ *   - command  : run a shell check (test/build/lint); pass = exit 0
+ *   - predicate: assert over the agent's output (regex | contains | jsonpath)
+ *   - llm_judge: a separate model judges done/criteria → {pass, reason}
+ *   - rubric   : a separate model scores weighted dimensions → score ≥ threshold
+ *
+ * Reuses the consensus/quorum vocabulary from self-evolution (VerifierResult).
+ */
+import { type Policy } from "./sandbox.js";
+import type { ConsensusResult } from "./self-evolution.js";
+export type VerificationMode = "off" | "advisory" | "blocking";
+export type OnFail = "retry" | "skip" | "stop";
+export interface VerificationGate {
+    type: "command" | "predicate" | "llm_judge" | "rubric";
+    name?: string;
+    run?: string;
+    timeout_ms?: number;
+    kind?: "regex" | "jsonpath" | "contains";
+    expr?: string;
+    criteria?: string;
+    model?: string;
+    dimensions?: Array<{
+        name: string;
+        weight: number;
+        criteria?: string;
+    }>;
+    threshold?: number;
+}
+export interface VerificationConfig {
+    mode: VerificationMode;
+    quorum: "all" | "majority" | number;
+    onFail: OnFail;
+    maxRetries: number;
+    gates: VerificationGate[];
+}
+export declare const DEFAULT_VERIFICATION: VerificationConfig;
+export interface VerificationContext {
+    task: string;
+    /** The agent's final output / summary. */
+    output: string;
+    /** Full transcript text (for judges that need the trail). */
+    transcript?: string;
+}
+/** Optional LLM access for llm_judge / rubric gates (constrained JSON). */
+export interface JudgeConfig {
+    endpoint: string;
+    model: string;
+    apiKey?: string;
+    fetchImpl?: typeof fetch;
+}
+export interface VerifyOptions {
+    policy?: Policy;
+    judge?: JudgeConfig;
+}
+export declare function readVerification(frontmatter: Record<string, unknown>): VerificationConfig;
+/** Run all gates and apply the quorum. Returns a ConsensusResult (reused shape). */
+export declare function runVerification(config: VerificationConfig, ctx: VerificationContext, opts?: VerifyOptions): Promise<ConsensusResult>;

package/dist/verification.js

@@ -0,0 +1,190 @@
+/**
+ * Objective verification (v0.9 — spec `verification`): the maker≠checker split.
+ *
+ * The loop-engineering research is blunt: the #1 reason loops fail is "a second
+ * agent asked to review without an objective gate — two optimists agreeing", and
+ * "the model that wrote the code is too nice grading its own homework". So the
+ * agent that did the work NEVER decides done; an INDEPENDENT verifier does, and
+ * where possible it is deterministic (a command's exit code, a predicate) rather
+ * than an opinion. Four gate types cover coding AND non-coding domains:
+ *   - command  : run a shell check (test/build/lint); pass = exit 0
+ *   - predicate: assert over the agent's output (regex | contains | jsonpath)
+ *   - llm_judge: a separate model judges done/criteria → {pass, reason}
+ *   - rubric   : a separate model scores weighted dimensions → score ≥ threshold
+ *
+ * Reuses the consensus/quorum vocabulary from self-evolution (VerifierResult).
+ */
+import { executeCommand } from "./tools/exec.js";
+import { DEFAULT_POLICY } from "./sandbox.js";
+export const DEFAULT_VERIFICATION = {
+    mode: "off",
+    quorum: "all",
+    onFail: "retry",
+    maxRetries: 1,
+    gates: [],
+};
+export function readVerification(frontmatter) {
+    const v = frontmatter.verification;
+    if (!v)
+        return { ...DEFAULT_VERIFICATION };
+    const mode = v.mode === "advisory" || v.mode === "blocking" ? v.mode : "off";
+    const quorum = v.quorum === "majority" || (typeof v.quorum === "number" && v.quorum >= 1) ? v.quorum : "all";
+    const onFail = v.on_fail === "skip" || v.on_fail === "stop" ? v.on_fail : "retry";
+    const maxRetries = typeof v.max_retries === "number" && v.max_retries >= 0 ? v.max_retries : 1;
+    const gates = Array.isArray(v.gates) ? v.gates : [];
+    return { mode, quorum, onFail, maxRetries, gates };
+}
+function resolveQuorum(n, quorum) {
+    if (quorum === "all")
+        return n;
+    if (quorum === "majority")
+        return Math.floor(n / 2) + 1;
+    return Math.min(Math.max(1, quorum), n);
+}
+// ── Individual gate verifiers ────────────────────────────────────────────────
+async function verifyCommand(gate, policy) {
+    const name = gate.name ?? `command:${(gate.run ?? "").slice(0, 24)}`;
+    if (!gate.run)
+        return { verifier: name, pass: false, reason: "no command specified" };
+    const r = await executeCommand(gate.run, policy, { timeoutMs: gate.timeout_ms });
+    return {
+        verifier: name,
+        pass: r.ok,
+        reason: r.ok ? `exit 0` : `exit ${r.code}${r.timedOut ? " (timeout)" : ""}: ${(r.stderr || r.stdout).split("\n")[0].slice(0, 120)}`,
+    };
+}
+function verifyPredicate(gate, output) {
+    const name = gate.name ?? `predicate:${gate.kind}`;
+    const expr = gate.expr ?? "";
+    let pass = false;
+    let reason = "";
+    try {
+        if (gate.kind === "regex") {
+            pass = new RegExp(expr).test(output);
+            reason = pass ? "regex matched" : "regex did not match";
+        }
+        else if (gate.kind === "contains") {
+            pass = output.includes(expr);
+            reason = pass ? "substring present" : "substring absent";
+        }
+        else if (gate.kind === "jsonpath") {
+            const val = jsonPath(output, expr);
+            pass = val !== undefined && val !== null && val !== false;
+            reason = pass ? `path ${expr} present/truthy` : `path ${expr} missing/falsy`;
+        }
+        else {
+            reason = `unknown predicate kind '${gate.kind}'`;
+        }
+    }
+    catch (e) {
+        reason = `predicate error: ${e.message}`;
+    }
+    return { verifier: name, pass, reason };
+}
+/** Minimal `$.a.b[0]` resolver over JSON.parse(output). Best-effort, dependency-free. */
+function jsonPath(output, path) {
+    let obj;
+    try {
+        obj = JSON.parse(output);
+    }
+    catch {
+        const m = output.match(/\{[\s\S]*\}/);
+        if (!m)
+            return undefined;
+        try {
+            obj = JSON.parse(m[0]);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const parts = path.replace(/^\$\.?/, "").split(/[.\[\]]+/).filter(Boolean);
+    let cur = obj;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== "object")
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+async function judgeJson(judge, system, user) {
+    const fetchImpl = judge.fetchImpl ?? fetch;
+    const res = await fetchImpl(`${judge.endpoint.replace(/\/$/, "")}/chat/completions`, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...(judge.apiKey ? { authorization: `Bearer ${judge.apiKey}` } : {}) },
+        body: JSON.stringify({
+            model: judge.model,
+            messages: [{ role: "system", content: system }, { role: "user", content: user }],
+            temperature: 0,
+            response_format: { type: "json_object" },
+        }),
+    });
+    if (!res.ok)
+        throw new Error(`judge HTTP ${res.status}`);
+    const json = (await res.json());
+    const content = json.choices?.[0]?.message?.content ?? "{}";
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        const m = content.match(/\{[\s\S]*\}/);
+        return m ? JSON.parse(m[0]) : null;
+    }
+}
+async function verifyLlmJudge(gate, ctx, judge) {
+    const name = gate.name ?? "llm_judge";
+    if (!judge)
+        return { verifier: name, pass: true, reason: "skipped (no judge model configured)" };
+    try {
+        const out = await judgeJson({ ...judge, model: gate.model ?? judge.model }, "You are an INDEPENDENT verifier. You did not do the work. Decide strictly whether the result meets the criteria. Output JSON {\"pass\": boolean, \"reason\": string}.", `# Criteria\n${gate.criteria ?? "Task fully and correctly completed."}\n\n# Task\n${ctx.task}\n\n# Result\n${ctx.output.slice(0, 4000)}`);
+        const pass = out?.pass === true;
+        return { verifier: name, pass, reason: typeof out?.reason === "string" ? out.reason.slice(0, 160) : pass ? "met" : "not met" };
+    }
+    catch (e) {
+        return { verifier: name, pass: false, reason: `judge error: ${e.message}` };
+    }
+}
+async function verifyRubric(gate, ctx, judge) {
+    const name = gate.name ?? "rubric";
+    const dims = gate.dimensions ?? [];
+    const threshold = typeof gate.threshold === "number" ? gate.threshold : 0.7;
+    if (!judge)
+        return { verifier: name, pass: true, reason: "skipped (no judge model configured)" };
+    try {
+        const out = await judgeJson({ ...judge, model: gate.model ?? judge.model }, "You are an INDEPENDENT grader. Score each dimension 0..1. Output JSON {\"scores\": {<dim>: number}, \"notes\": string}.", `# Dimensions\n${dims.map((d) => `- ${d.name} (weight ${d.weight})${d.criteria ? ": " + d.criteria : ""}`).join("\n")}\n\n# Criteria\n${gate.criteria ?? ""}\n\n# Task\n${ctx.task}\n\n# Result\n${ctx.output.slice(0, 4000)}`);
+        const scores = (out?.scores ?? {});
+        const totalW = dims.reduce((s, d) => s + d.weight, 0) || 1;
+        const agg = dims.reduce((s, d) => s + (Number(scores[d.name]) || 0) * d.weight, 0) / totalW;
+        const pass = agg >= threshold;
+        return { verifier: name, pass, reason: `score ${agg.toFixed(2)} ${pass ? "≥" : "<"} threshold ${threshold}` };
+    }
+    catch (e) {
+        return { verifier: name, pass: false, reason: `rubric error: ${e.message}` };
+    }
+}
+/** Run all gates and apply the quorum. Returns a ConsensusResult (reused shape). */
+export async function runVerification(config, ctx, opts = {}) {
+    const policy = opts.policy ?? DEFAULT_POLICY;
+    const results = [];
+    for (const gate of config.gates) {
+        switch (gate.type) {
+            case "command":
+                results.push(await verifyCommand(gate, policy));
+                break;
+            case "predicate":
+                results.push(verifyPredicate(gate, ctx.output));
+                break;
+            case "llm_judge":
+                results.push(await verifyLlmJudge(gate, ctx, opts.judge));
+                break;
+            case "rubric":
+                results.push(await verifyRubric(gate, ctx, opts.judge));
+                break;
+            default:
+                results.push({ verifier: `unknown:${gate.type}`, pass: false, reason: "unknown gate type" });
+        }
+    }
+    const quorum = resolveQuorum(results.length || 1, config.quorum);
+    const passes = results.filter((r) => r.pass).length;
+    return { passed: results.length === 0 ? true : passes >= quorum, results, quorum, passes };
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@personaxis/core",
+  "version": "0.11.0",
+  "description": "Personaxis engine: governed Living Loop, bounded memory, state/envelope mutation, persona sigil. Spec-faithful, framework-agnostic.",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.10.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/personaxis/cli.git",
+    "directory": "packages/core"
+  },
+  "scripts": {
+    "build": "node ./scripts/gen-version.mjs && tsc",
+    "lint": "node ./scripts/gen-version.mjs && tsc --noEmit",
+    "test": "node ./scripts/gen-version.mjs && vitest run"
+  }
+}