@intutic/cli 1.9.0 → 1.10.1

package/dist/commands/guardrails.js

@@ -0,0 +1,735 @@
+/**
+ * `intutic guardrails` — the Policy Clause Ledger from the terminal
+ * (LLD #71, Wave 6): sources, documents, the review queue, and the three
+ * decisions that move a cited guardrail. A client of
+ * `/api/v1/policy-guardrails/*` and `/api/v1/connectors`; nothing here
+ * decides anything the server would not.
+ *
+ * Not `intutic policy` (the WASM rule loop) and not `intutic sops` (the
+ * file plane). The acting identity is never a flag: the server records the
+ * authenticated member, so a client-supplied name cannot forge the audit
+ * trail — same rule as `intutic findings adjudicate`.
+ */
+import { readFile, writeFile, mkdir, readdir, unlink } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { log } from '../lib/logger.js';
+import { parseSopFile, withContentHash } from '../lib/sopFrontMatter.js';
+import { NOT_AUTHENTICATED } from '../lib/authMessages.js';
+import { loadCredentials, loadConfig } from '../config/store.js';
+import { resolveControlPlaneUrl } from '../config/paths.js';
+import { createApiClient } from '../lib/api.js';
+import { SOURCE_PROVIDERS, GUARDRAIL_STATUSES, GUARDRAIL_TARGETS, guardrailIdFromSopTitle, guardrailFileStem, } from '@intutic/shared-types';
+const BASE = '/api/v1/policy-guardrails';
+function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function getClient(dev) {
+    const creds = await loadCredentials();
+    if (!creds) {
+        log.error(NOT_AUTHENTICATED);
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const devMode = dev || config?.devMode || process.env.INTUTIC_DEV === '1';
+    return createApiClient(resolveControlPlaneUrl(devMode), creds.apiKey);
+}
+function emitJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+/** A null rate is "no measured rate" — never invented as 0%. */
+function formatRate(rate) {
+    return rate === null ? 'no measured rate' : `${(rate * 100).toFixed(1)}%`;
+}
+const enc = encodeURIComponent;
+export async function runGuardrailsSourcesList(opts) {
+    const client = await getClient(opts.dev);
+    let items;
+    try {
+        const res = await client.get('/api/v1/connectors');
+        items = (res.items ?? []).filter((c) => SOURCE_PROVIDERS.includes(c.provider));
+    }
+    catch (err) {
+        log.error(`Failed to list policy sources: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(items);
+        return;
+    }
+    log.header('Intutic — Policy Sources');
+    if (items.length === 0) {
+        log.info(`No policy sources. Add one with \`intutic guardrails sources add <${SOURCE_PROVIDERS.join('|')}> --name … --token …\`.`);
+        return;
+    }
+    for (const c of items) {
+        const id = c.connector_id ?? c.connectorId ?? '?';
+        const synced = c.last_synced_at ?? c.lastSyncedAt ?? null;
+        const cfg = c.config ?? {};
+        log.field(c.name, `${id} — ${c.provider}${cfg.auto_sync === true ? ', auto-sync' : ''}${synced ? `, last synced ${synced}` : ', never synced'}`);
+    }
+    log.info(`${items.length} policy source(s).`);
+}
+export async function runGuardrailsSourcesAdd(provider, opts) {
+    if (!SOURCE_PROVIDERS.includes(provider)) {
+        log.error(`Provider must be one of ${SOURCE_PROVIDERS.join(', ')}.`);
+        process.exit(1);
+    }
+    if (!opts.name) {
+        log.error('--name is required.');
+        process.exit(1);
+    }
+    if (Boolean(opts.token) === Boolean(opts.tokenFile)) {
+        log.error('Give the credential with exactly one of --token or --token-file (a Google service-account key is a file).');
+        process.exit(1);
+    }
+    let credential = opts.token ?? '';
+    if (opts.tokenFile) {
+        try {
+            credential = (await readFile(opts.tokenFile, 'utf8')).trim();
+        }
+        catch (err) {
+            log.error(`Could not read --token-file: ${errMessage(err)}`);
+            process.exit(1);
+        }
+        if (!credential) {
+            log.error('--token-file is empty.');
+            process.exit(1);
+        }
+    }
+    let config = {};
+    if (opts.config) {
+        try {
+            const parsed = JSON.parse(opts.config);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error('not an object');
+            config = parsed;
+        }
+        catch (err) {
+            log.error(`--config must be a JSON object: ${errMessage(err)}`);
+            process.exit(1);
+        }
+    }
+    const client = await getClient(opts.dev);
+    try {
+        const res = await client.post('/api/v1/connectors', {
+            provider,
+            name: opts.name,
+            token: credential,
+            config,
+        });
+        const id = res.connector?.connector_id ?? res.connector?.connectorId ?? res.connectorId ?? res.connector_id ?? '(see dashboard)';
+        if (opts.json) {
+            emitJson(res);
+            return;
+        }
+        log.success(`Added ${provider} source "${opts.name}" (${id}). Sync it with \`intutic guardrails sources sync ${id}\`.`);
+    }
+    catch (err) {
+        log.error(`Failed to add source: ${errMessage(err)}`);
+        process.exit(1);
+    }
+}
+export async function runGuardrailsSourcesSync(connectorId, opts) {
+    const client = await getClient(opts.dev);
+    try {
+        const res = await client.post(`/api/v1/connectors/${enc(connectorId)}/sync`, {});
+        if (opts.json) {
+            emitJson(res);
+            return;
+        }
+        log.success(`Synced ${connectorId}.`);
+        log.field('Documents processed', String(res.processedCount ?? 0));
+        log.field('Documents changed', String(res.changedDocIds?.length ?? 0));
+        log.field('SOPs written', String(res.updatedSopIds?.length ?? 0));
+        if (res.successorSopIds?.length)
+            log.field('Upstream successors', String(res.successorSopIds.length));
+        if (res.upstreamDeleted?.length)
+            log.field('Upstream deleted', res.upstreamDeleted.join(', '));
+        if (res.staleGuardrailIds?.length)
+            log.warn(`${res.staleGuardrailIds.length} guardrail citation(s) went stale: ${res.staleGuardrailIds.join(', ')}`);
+    }
+    catch (err) {
+        log.error(`Failed to sync source: ${errMessage(err)}`);
+        process.exit(1);
+    }
+}
+// ─── docs ───────────────────────────────────────────────────────────
+export async function runGuardrailsDocsList(opts) {
+    const client = await getClient(opts.dev);
+    let documents;
+    try {
+        documents = (await client.get(`${BASE}/documents`)).documents ?? [];
+    }
+    catch (err) {
+        log.error(`Failed to list documents: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(documents);
+        return;
+    }
+    log.header('Intutic — Policy Documents');
+    if (documents.length === 0) {
+        log.info('No documents yet. Sync a source first.');
+        return;
+    }
+    for (const d of documents) {
+        log.field(d.title, `${d.docId} — ${d.provider}, ${d.passageCount} passage(s), ${d.clauseCount} clause(s), ${d.guardrailCount} guardrail(s)${d.injectionFlagged ? ', INJECTION-FLAGGED' : ''}${d.lastRun ? `, last extraction ${d.lastRun.extractor} at ${d.lastRun.startedAt}${d.lastRun.error ? ` (error: ${d.lastRun.error})` : ''}` : ', never extracted'}`);
+    }
+    log.info(`${documents.length} document(s).`);
+}
+export async function runGuardrailsDocsShow(docId, opts) {
+    const client = await getClient(opts.dev);
+    const { status, body } = await client.getWithStatus(`${BASE}/documents/${enc(docId)}`);
+    if (status === 404) {
+        log.error(`Document "${docId}" not found in this workspace.`);
+        process.exit(1);
+    }
+    if (status !== 200 || !body.document) {
+        log.error(`Failed to load document (${status}): ${body.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    const d = body.document;
+    if (opts.json) {
+        emitJson(d);
+        return;
+    }
+    log.header(`Intutic — ${d.title}`);
+    log.field('Document', d.docId);
+    log.field('Source', `${d.provider}${d.sourceUrl ? ` ${d.sourceUrl}` : ''}`);
+    log.field('Content', `${d.contentHash.slice(0, 12)}${d.upstreamVersion ? ` (upstream ${d.upstreamVersion})` : ''}`);
+    log.field('Passages', String(d.passages.length));
+    if (d.injectionFlagged)
+        log.warn('This document is flagged for prompt-injection phrasing; its guardrails are created REJECTED.');
+    if (d.clauses.length === 0)
+        log.info('No clauses extracted yet. Run `intutic guardrails docs extract <docId>`.');
+    for (const c of d.clauses) {
+        const refused = Array.isArray(c.validation) ? c.validation.filter((v) => !v.passed).map((v) => v.name) : [];
+        log.field(`${c.kind} [${c.status}]`, `${c.clauseId}${c.guardrailId ? ` → ${c.guardrailStatus} guardrail ${c.guardrailId}` : ''}${refused.length ? ` — refused by ${refused.join(', ')}` : ''}`);
+        log.dim(`    "${c.quote}"`);
+    }
+    for (const r of d.runs) {
+        log.dim(`  run ${r.runId}: ${r.extractor} — ${r.clausesValid} valid / ${r.clausesRejected} refused${r.error ? ` — ${r.error}` : ''}`);
+    }
+}
+export async function runGuardrailsDocsExtract(docId, opts) {
+    const client = await getClient(opts.dev);
+    const { status, body } = await client.postWithStatus(`${BASE}/documents/${enc(docId)}/extract`, { llm: !opts.noLlm });
+    if (status === 404) {
+        log.error(`Document "${docId}" not found in this workspace.`);
+        process.exit(1);
+    }
+    if (status === 403) {
+        log.error(body.error ?? 'Extraction needs a paid plan or an active trial.');
+        process.exit(1);
+    }
+    if (status === 429) {
+        log.warn(`Daily extraction cap reached (${body.cap?.count ?? '?'} of ${body.cap?.cap ?? '?'} calls today). The front-matter lift still ran.`);
+        process.exit(1);
+    }
+    if (status !== 200 || !body.result) {
+        log.error(`Extraction failed (${status}): ${body.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    const r = body.result;
+    if (opts.json) {
+        emitJson(r);
+        return;
+    }
+    if (r.skipped === 'llm_disabled')
+        log.info('Model call skipped (--no-llm); only the front-matter lift ran.');
+    else if (r.skipped === 'no_passages')
+        log.warn('The document has no passages to extract from.');
+    else if (r.skipped === 'cap_unavailable')
+        log.warn('The cap store was unreachable, so no model call was made.');
+    else if (r.llmUnavailable)
+        log.warn(`The model could not be reached: ${r.error ?? 'no detail'}. The run is recorded with its error.`);
+    else
+        log.success(`Extracted ${docId}: ${r.proposals} proposal(s) from ${r.chunks} chunk(s).`);
+    log.field('Valid clauses', String(r.valid));
+    log.field('Refused by a check', String(r.rejected));
+    log.field('Malformed', String(r.malformed));
+    log.field('Guardrails proposed', String(r.guardrails.proposed));
+    if (r.guardrails.rejectedForInjection > 0)
+        log.field('Rejected (injection-flagged document)', String(r.guardrails.rejectedForInjection));
+    if (r.guardrails.existing > 0)
+        log.field('Already existed', String(r.guardrails.existing));
+    if (r.lifted.clauses > 0)
+        log.field('Front-matter rules lifted', String(r.lifted.clauses));
+    if (r.runId)
+        log.dim(`  run ${r.runId}`);
+}
+// ─── search ─────────────────────────────────────────────────────────
+export async function runGuardrailsSearch(token, opts) {
+    if (opts.text)
+        return runPassageTextSearch(token, opts);
+    if (!token.trim()) {
+        log.error('A tool name or action token is required, e.g. `intutic guardrails search bash`.');
+        process.exit(1);
+    }
+    const client = await getClient(opts.dev);
+    let coverage;
+    try {
+        coverage = (await client.get(`${BASE}/coverage?token=${enc(token.trim())}`)).coverage;
+    }
+    catch (err) {
+        log.error(`Search failed: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(coverage);
+        return;
+    }
+    log.header(`Intutic — Passages mentioning "${coverage.token}"`);
+    if (coverage.passages.length === 0) {
+        log.info('No passage mentions it. A guardrail naming it would have nothing to cite.');
+        return;
+    }
+    for (const p of coverage.passages) {
+        log.field(p.title, `${p.headingPath.join(' › ') || '(no heading)'} — ${p.excerpt}`);
+    }
+    log.info(`${coverage.passages.length} passage(s); ${coverage.guardrails.length} guardrail(s) stand on them.`);
+    for (const g of coverage.guardrails)
+        log.dim(`  ${g.guardrailId} [${g.status}] ${g.target} — "${g.quote}"`);
+}
+/** `search --text`: the words of every live passage, stemmed, best match first. */
+async function runPassageTextSearch(query, opts) {
+    if (!query.trim()) {
+        log.error('Words to search for are required, e.g. `intutic guardrails search --text "production deploy"`.');
+        process.exit(1);
+    }
+    const client = await getClient(opts.dev);
+    let result;
+    try {
+        result = (await client.get(`${BASE}/search?q=${enc(query.trim())}`)).search;
+    }
+    catch (err) {
+        log.error(`Search failed: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(result);
+        return;
+    }
+    log.header(`Intutic — Passages about "${result.query}"`);
+    if (result.passages.length === 0) {
+        log.info('No live passage matches those words.');
+        return;
+    }
+    for (const p of result.passages) {
+        log.field(p.title, `${p.headingPath.join(' › ') || '(no heading)'} — ${p.excerpt}`);
+    }
+    log.info(`${result.passages.length} passage(s), best match first.`);
+}
+// ─── impact / duplicates ────────────────────────────────────────────
+export async function runGuardrailsImpact(opts) {
+    if (!opts.doc === !opts.passage) {
+        log.error('Name exactly one of --doc <docId> or --passage <passageId>.');
+        process.exit(1);
+    }
+    const client = await getClient(opts.dev);
+    const seed = opts.doc ? `docId=${enc(opts.doc)}` : `passageId=${enc(opts.passage)}`;
+    let impact;
+    try {
+        impact = (await client.get(`${BASE}/impact?${seed}`)).impact;
+    }
+    catch (err) {
+        log.error(`Impact failed: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(impact);
+        return;
+    }
+    log.header(`Intutic — What a change to ${opts.doc ?? opts.passage} reaches`);
+    log.field('Passages', `${impact.passages.length} within ${impact.maxDepth} computed edge(s)${impact.truncated ? ' (capped)' : ''}`);
+    log.field('Clauses citing them', String(impact.clauses.length));
+    log.field('Guardrails', String(impact.guardrails.length));
+    for (const g of impact.guardrails) {
+        log.dim(`  ${g.guardrailId} [${g.status}${g.sourceStale ? ', stale' : ''}] ${g.target}, ${g.depth} edge(s) from the change`);
+    }
+    if (impact.guardrails.some((g) => g.status === 'ENFORCING')) {
+        log.warn('An enforcing guardrail stands on this text. An upstream edit marks it stale for review; it never switches enforcement off.');
+    }
+}
+export async function runGuardrailsDuplicates(opts) {
+    let query = '';
+    if (opts.minJaccard !== undefined) {
+        const n = Number(opts.minJaccard);
+        if (opts.minJaccard.trim() === '' || !Number.isFinite(n) || n < 0 || n > 1) {
+            log.error('--min-jaccard must be a number between 0 and 1.');
+            process.exit(1);
+        }
+        query = `?minJaccard=${n}`;
+    }
+    const client = await getClient(opts.dev);
+    let d;
+    try {
+        d = (await client.get(`${BASE}/duplicates${query}`)).duplicates;
+    }
+    catch (err) {
+        log.error(`Failed to list duplicates: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(d);
+        return;
+    }
+    log.header('Intutic — Duplicate passages and repeated rules');
+    if (d.passagePairs.length === 0 && d.sameRule.length === 0) {
+        log.info(`No passages overlap at Jaccard ${d.minJaccard.toFixed(2)} or above, and no rule is cited twice.`);
+        return;
+    }
+    for (const pp of d.passagePairs) {
+        log.field(`Jaccard ${pp.jaccard.toFixed(2)}${pp.nearIdentical ? ', near-identical' : ''}`, `${pp.a.title} and ${pp.b.title} (${pp.intersection} of ${pp.union} shingles shared)`);
+        log.dim(`    ${pp.a.passageId}: ${pp.a.excerpt}`);
+        log.dim(`    ${pp.b.passageId}: ${pp.b.excerpt}`);
+    }
+    for (const r of d.sameRule) {
+        log.field(`The same ${r.kind} rule`, `cited ${r.clauses.length} times`);
+        for (const c of r.clauses)
+            log.dim(`    ${c.clauseId} in ${c.title}${c.guardrailId ? ` (${c.guardrailId}, ${c.guardrailStatus})` : ''}: "${c.quote}"`);
+    }
+    log.info(`${d.passagePairs.length} overlapping pair(s); ${d.sameRule.length} repeated rule(s).`);
+}
+// ─── guardrails ─────────────────────────────────────────────────────
+export async function runGuardrailsList(opts) {
+    const params = new URLSearchParams();
+    if (opts.status !== undefined) {
+        if (!GUARDRAIL_STATUSES.includes(opts.status)) {
+            log.error(`--status must be one of ${GUARDRAIL_STATUSES.join(', ')}.`);
+            process.exit(1);
+        }
+        params.set('status', opts.status);
+    }
+    if (opts.target !== undefined) {
+        if (!GUARDRAIL_TARGETS.includes(opts.target)) {
+            log.error(`--target must be one of ${GUARDRAIL_TARGETS.join(', ')}.`);
+            process.exit(1);
+        }
+        params.set('target', opts.target);
+    }
+    if (opts.doc)
+        params.set('docId', opts.doc);
+    if (opts.limit !== undefined) {
+        const n = Number(opts.limit);
+        if (!Number.isInteger(n) || n < 1) {
+            log.error('--limit must be a positive integer.');
+            process.exit(1);
+        }
+        params.set('limit', String(n));
+    }
+    const client = await getClient(opts.dev);
+    let guardrails;
+    try {
+        const q = params.toString();
+        guardrails = (await client.get(`${BASE}/guardrails${q ? `?${q}` : ''}`)).guardrails ?? [];
+    }
+    catch (err) {
+        log.error(`Failed to list guardrails: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(guardrails);
+        return;
+    }
+    log.header('Intutic — Policy Guardrails');
+    if (guardrails.length === 0) {
+        log.info(`No guardrails${opts.status ? ` with status ${opts.status}` : ''}.`);
+        return;
+    }
+    for (const g of guardrails) {
+        const ir = g.ir;
+        const title = ir.title ?? ir.kind;
+        log.field(`${g.guardrailId} [${g.status}${g.sourceStale ? ', stale' : ''}]`, `${g.target} — ${title}`);
+        log.dim(`    "${g.clause.quote}" — ${g.document.title}${g.document.sourceUrl ? ` ${g.document.sourceUrl}` : ''}`);
+        if (g.status === 'SHADOW')
+            log.dim(`    shadow: ${g.shadowEvaluations} evaluation(s), ${g.shadowWouldAct} would-act`);
+    }
+    log.info(`${guardrails.length} guardrail(s).`);
+}
+function printReadiness(r) {
+    log.field('Ready to enforce', r.ready ? (r.neverFired ? 'yes — but no observed traffic exercised it; promote with --acknowledge-no-traffic' : 'yes') : 'no');
+    log.field('Shadow evaluations', `${r.evaluations}/${r.thresholds.minShadowEvaluations}`);
+    log.field('Would-act rate', `${formatRate(r.wouldActRate)} (ceiling ${(r.thresholds.maxWouldActRate * 100).toFixed(0)}%)`);
+    log.field('Adjudicated fires', `${r.adjudicated}/${r.adjudicatedRequired}, FP rate ${formatRate(r.falsePositiveRate)} (ceiling ${(r.thresholds.maxAdjudicatedFalsePositiveRate * 100).toFixed(0)}%)`);
+    for (const reason of r.reasons)
+        log.dim(`    ${reason}`);
+}
+export async function runGuardrailsShow(guardrailId, opts) {
+    const client = await getClient(opts.dev);
+    const { status, body } = await client.getWithStatus(`${BASE}/guardrails/${enc(guardrailId)}`);
+    if (status === 404) {
+        log.error(`Guardrail "${guardrailId}" not found in this workspace.`);
+        process.exit(1);
+    }
+    if (status !== 200 || !body.guardrail) {
+        log.error(`Failed to load guardrail (${status}): ${body.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    const g = body.guardrail;
+    let readiness = null;
+    if (g.status === 'SHADOW') {
+        try {
+            readiness = (await client.get(`${BASE}/guardrails/${enc(guardrailId)}/readiness`)).readiness;
+        }
+        catch {
+            readiness = null;
+        }
+    }
+    if (opts.json) {
+        emitJson({ guardrail: g, readiness });
+        return;
+    }
+    const ir = g.ir;
+    log.header(`Intutic — ${ir.title ?? ir.kind}`);
+    log.field('Guardrail', `${g.guardrailId} [${g.status}${g.sourceStale ? ', stale citation' : ''}] ${g.target}`);
+    log.field('Cites', `"${g.clause.quote}"`);
+    log.field('From', `${g.document.title} (${g.document.provider})${g.document.sourceUrl ? ` ${g.document.sourceUrl}` : ''} — passage ${g.clause.passageHash.slice(0, 12)}`);
+    const rendered = g.rendered;
+    if (g.target === 'hook_rule' && rendered.toolPattern) {
+        log.field('Tool pattern', rendered.toolPattern);
+        if (rendered.argPattern)
+            log.field('Input pattern', rendered.argPattern);
+        log.field('On block', `[Intutic Governance] BLOCKED: ${rendered.reason ?? ''} [sop.guardrail.${g.guardrailId}]`);
+    }
+    else if (g.target === 'sop_front_matter' && rendered.lines) {
+        log.field('Front matter', '');
+        for (const line of rendered.lines.split('\n'))
+            log.dim(`    ${line}`);
+    }
+    else if (g.target === 'wasm_rule' && rendered.source) {
+        log.field('Predicate source', '');
+        for (const line of rendered.source.split('\n'))
+            log.dim(`    ${line}`);
+    }
+    if (g.status === 'REJECTED' && g.rejectedReason)
+        log.field('Rejected', g.rejectedReason);
+    if (readiness)
+        printReadiness(readiness);
+    const checks = Array.isArray(g.validation) ? g.validation : [];
+    if (checks.length > 0)
+        log.field('Checks', checks.map((c) => `${c.passed ? '✓' : '✗'} ${c.name}`).join('  '));
+    for (const e of g.events)
+        log.dim(`  ${e.createdAt} ${e.event}${e.actorId ? ` by ${e.actorId}` : ' (system)'}`);
+}
+async function transition(guardrailId, action, body, opts, done) {
+    const client = await getClient(opts.dev);
+    const { status, body: res } = await client.postWithStatus(`${BASE}/guardrails/${enc(guardrailId)}/${action}`, body);
+    if (status === 404) {
+        log.error(`Guardrail "${guardrailId}" not found in this workspace.`);
+        process.exit(1);
+    }
+    if (status === 403) {
+        log.error(res.error ?? 'Refused: a guardrail transition needs a signed-in member of the workspace.');
+        process.exit(1);
+    }
+    if (status === 409) {
+        log.error(res.error ?? `Refused (${res.code ?? 'conflict'}).`);
+        if (res.readiness)
+            printReadiness(res.readiness);
+        process.exit(1);
+    }
+    if (status !== 200 || !res.guardrail) {
+        log.error(`${action} failed (${status}): ${res.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(res);
+        return;
+    }
+    log.success(`${guardrailId}: ${done}`);
+    if (res.readiness)
+        printReadiness(res.readiness);
+    if (action === 'approve-shadow' && res.guardrail.target === 'wasm_rule' && res.guardrail.ruleCandidateId) {
+        // A wasm guardrail is enforced by nothing this row projects: it was handed
+        // to the rule-candidate pipeline, and the next step is a compile.
+        log.info(`Handed off to rule candidate ${res.guardrail.ruleCandidateId}. Next: intutic policy compile --candidate ${res.guardrail.ruleCandidateId} --upload`);
+    }
+    const last = res.guardrail.events.at(-1);
+    if (last)
+        log.dim(`  ${last.event}${last.actorId ? ` by ${last.actorId}` : ''}`);
+}
+export async function runGuardrailsApproveShadow(guardrailId, opts) {
+    await transition(guardrailId, 'approve-shadow', {}, opts, 'now in SHADOW — distributed as warn, measuring, enforcing nothing.');
+}
+export async function runGuardrailsPromote(guardrailId, opts) {
+    await transition(guardrailId, 'promote', { acknowledgeNoTraffic: opts.acknowledgeNoTraffic === true }, opts, 'now ENFORCING.');
+}
+export async function runGuardrailsReject(guardrailId, opts) {
+    if (!opts.reason || !opts.reason.trim()) {
+        log.error('--reason is required; the rejection is recorded with it.');
+        process.exit(1);
+    }
+    await transition(guardrailId, 'reject', { reason: opts.reason.trim() }, opts, 'rejected.');
+}
+export async function runGuardrailsRetire(guardrailId, opts) {
+    await transition(guardrailId, 'retire', {}, opts, 'retired — gone from every rule endpoint on the next poll.');
+}
+export async function runGuardrailsReconfirm(guardrailId, opts) {
+    await transition(guardrailId, 'reconfirm', {}, opts, 'citation re-confirmed against a live passage.');
+}
+export async function runGuardrailsReplay(guardrailId, opts) {
+    const client = await getClient(opts.dev);
+    const { status, body } = await client.postWithStatus(`${BASE}/guardrails/${enc(guardrailId)}/replay`, {});
+    if (status === 404) {
+        log.error(`Guardrail "${guardrailId}" not found in this workspace, or it has no replay (WASM candidates replay through \`intutic policy replay\`).`);
+        process.exit(1);
+    }
+    if (status !== 200 || !body.replay) {
+        log.error(`Replay failed (${status}): ${body.error ?? 'unknown error'}`);
+        process.exit(1);
+    }
+    const r = body.replay;
+    if (opts.json) {
+        emitJson(r);
+        return;
+    }
+    log.header(`Intutic — Replay ${guardrailId}`);
+    log.field('Would have fired', `${r.fires} of ${r.captured} captured call(s)`);
+    log.field('Source', `${r.source === 'enforcement_log' ? 'hook-gate and proxy verdicts with a captured input' : 'sampled request contexts'}, last ${r.windowDays} day(s)${r.truncated ? ', capped' : ''}`);
+    if (r.unsupported.length > 0)
+        log.warn(`Cannot be replayed: ${r.unsupported.join(', ')}`);
+    for (const s of r.sample)
+        log.dim(`  ${s.at} ${s.toolName}: ${s.excerpt}`);
+}
+export async function runGuardrailsConflicts(opts) {
+    const client = await getClient(opts.dev);
+    let conflicts;
+    try {
+        conflicts = (await client.get(`${BASE}/conflicts`)).conflicts ?? [];
+    }
+    catch (err) {
+        log.error(`Failed to detect conflicts: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    if (opts.json) {
+        emitJson(conflicts);
+        return;
+    }
+    log.header('Intutic — Guardrail Conflicts');
+    if (conflicts.length === 0) {
+        log.info('No two live guardrails or lifted front-matter rules contradict each other.');
+        return;
+    }
+    for (const c of conflicts) {
+        log.field(c.kind, `${c.token ?? ''} — ${c.detail}`);
+        log.dim(`    ${c.a.id}: "${c.a.quote}"`);
+        log.dim(`    ${c.b.id}: "${c.b.quote}"`);
+    }
+    log.info(`${conflicts.length} conflict(s).`);
+}
+const sha256 = (text) => createHash('sha256').update(text, 'utf8').digest('hex');
+/**
+ * `intutic guardrails pull` — the SHADOW and ENFORCING front-matter
+ * guardrails `GET /api/v1/workspace/sops-policy` serves, written to
+ * `.intutic/sops/guardrail-<id>.md` for a proxy that reads SOPs from disk.
+ *
+ * Flat, not in a subdirectory: the proxy's loader reads one directory level
+ * and titles each SOP by its file stem, and `guardrail-<id>` is a stem the
+ * control plane credits shadow reports to. The served markdown already
+ * carries its own front-matter fence with the enforcing keys and
+ * `mode: shadow`; `withContentHash` puts the pull marker inside that fence
+ * rather than wrapping a second one the proxy would never read.
+ *
+ * Same overwrite rule as `intutic sops pull`: a file whose recorded hash no
+ * longer matches its body was edited by hand and is left alone without
+ * `--force`. A file for a guardrail that is no longer served (retired or
+ * rejected) is reported — a proxy reading the directory still enforces it —
+ * and removed only with `--prune`, and only when it is unmodified.
+ */
+export async function runGuardrailsPull(opts) {
+    const config = loadConfig();
+    const workspaceRoot = config?.workspaceRoot ?? process.cwd();
+    const sopsDir = join(workspaceRoot, '.intutic', 'sops');
+    const say = (level, message) => {
+        if (opts.json)
+            return;
+        if (level === 'warn')
+            log.warn(message);
+        else
+            log.info(message);
+    };
+    if (!opts.json)
+        log.header('Intutic — Pull Guardrails');
+    const client = await getClient(opts.dev);
+    let served;
+    try {
+        served = (await client.get('/api/v1/workspace/sops-policy')).sops ?? [];
+    }
+    catch (err) {
+        log.error(`Failed to fetch the workspace SOP policy: ${errMessage(err)}`);
+        process.exit(1);
+    }
+    const guardrails = served
+        .map((entry) => ({ id: guardrailIdFromSopTitle(entry.title), entry }))
+        .filter((x) => x.id !== null && typeof x.entry.markdownContent === 'string' && x.entry.markdownContent.trim().length > 0);
+    await mkdir(sopsDir, { recursive: true });
+    const written = [];
+    const unchanged = [];
+    const skipped = [];
+    const servedStems = new Set();
+    for (const { id, entry } of guardrails) {
+        const stem = guardrailFileStem(id);
+        servedStems.add(stem);
+        const filePath = join(sopsDir, `${stem}.md`);
+        const rendered = withContentHash(`${entry.markdownContent.trim()}\n`);
+        const existing = await readFile(filePath, 'utf-8').catch(() => null);
+        if (existing !== null) {
+            if (existing === rendered) {
+                unchanged.push(stem);
+                continue;
+            }
+            if (!opts.force) {
+                const parsedExisting = parseSopFile(existing);
+                const dirty = parsedExisting.contentHash === null || parsedExisting.contentHash !== sha256(parsedExisting.body);
+                if (dirty) {
+                    say('warn', `${filePath}: locally modified (or not written by pull) — refusing to overwrite. Use --force to pull anyway.`);
+                    skipped.push(stem);
+                    continue;
+                }
+            }
+        }
+        await writeFile(filePath, rendered, 'utf-8');
+        written.push(stem);
+        say('info', `${filePath} ← ${entry.title}`);
+    }
+    // Files this command wrote for guardrails the server no longer serves.
+    const onDisk = (await readdir(sopsDir).catch(() => [])).filter((f) => /^guardrail-.+\.md$/.test(f));
+    const pruned = [];
+    const stale = [];
+    for (const file of onDisk) {
+        const stem = file.replace(/\.md$/, '');
+        if (servedStems.has(stem))
+            continue;
+        const filePath = join(sopsDir, file);
+        if (!opts.prune) {
+            say('warn', `${filePath}: no longer served (retired or rejected) — a proxy reading this directory still enforces it. Re-run with --prune to remove it.`);
+            stale.push(stem);
+            continue;
+        }
+        const existing = await readFile(filePath, 'utf-8').catch(() => null);
+        const parsed = existing !== null ? parseSopFile(existing) : null;
+        const clean = parsed !== null && parsed.contentHash !== null && parsed.contentHash === sha256(parsed.body);
+        if (!clean) {
+            say('warn', `${filePath}: no longer served but locally modified — left in place; remove it by hand.`);
+            stale.push(stem);
+            continue;
+        }
+        await unlink(filePath);
+        pruned.push(stem);
+        say('info', `${filePath}: removed (no longer served)`);
+    }
+    if (opts.json) {
+        emitJson({ sopsDir, written, unchanged, skipped, pruned, stale });
+        return;
+    }
+    if (guardrails.length === 0)
+        log.info('No SHADOW or ENFORCING front-matter guardrails are served for this workspace.');
+    log.info(`${written.length} written, ${unchanged.length} unchanged, ${skipped.length} left untouched, ${pruned.length} pruned, ${stale.length} stale — in ${sopsDir}.`);
+    if (skipped.length > 0)
+        log.info('Re-run with --force to overwrite locally-modified guardrail files.');
+    log.dim('A proxy that reads .intutic/sops from disk (standalone, or INTUTIC_SOPS_DIR) enforces these within 30 s. A gateway-mode proxy reads the served projection directly and ignores this directory.');
+}
+//# sourceMappingURL=guardrails.js.map