@skill-harness/cli 0.16.0 → 0.18.0

package/dist/archive-learning.js

@@ -1,153 +0,0 @@
-import { constants, openSync, readSync, fstatSync, closeSync } from 'node:fs';
-import { isAbsolute } from 'node:path';
-import { createArchiveAccess, openArchiveAccess, readFixedOrderFacts, createWeeklyInvestigation, openWeeklyInvestigation, createTrustLifecycle, openTrustLifecycle } from '@skill-harness/adapters';
-import { parseLearningRequest } from '@skill-harness/core';
-/** Explicit operator requests, not a scheduler or model route. The inert host cannot invoke this CLI. */
-export function cmdArchiveLearning(args) {
-    if (args._.length !== 1 || Object.keys(args.flags).sort().join() !== 'request,state' || typeof args.flags.state !== 'string' || !isAbsolute(args.flags.state) || typeof args.flags.request !== 'string')
-        throw Error('archive weekly|trust|access requires --state /absolute/directory --request file');
-    const fd = openSync(args.flags.request, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-    let text;
-    try {
-        const stat = fstatSync(fd);
-        if (!stat.isFile() || stat.size > 65536)
-            throw Error('bounded regular learning request required');
-        const bytes = Buffer.alloc(65537);
-        let n = 0;
-        while (n < bytes.length) {
-            const k = readSync(fd, bytes, n, bytes.length - n, n);
-            if (!k)
-                break;
-            n += k;
-        }
-        if (n > 65536)
-            throw Error('learning request exceeds bound');
-        text = new TextDecoder('utf-8', { fatal: true }).decode(bytes.subarray(0, n));
-    }
-    finally {
-        closeSync(fd);
-    }
-    const request = parseLearningRequest(text);
-    if (Object.keys(request).sort().join() !== 'authority,input,operation')
-        throw Error('closed learning request required');
-    const input = request.input, authority = request.authority, state = args.flags.state;
-    let result;
-    if (args._[0] === 'access') {
-        if (request.operation === 'create')
-            result = createArchiveAccess(state, input, authority).inspect();
-        else {
-            const access = openArchiveAccess(state);
-            switch (request.operation) {
-                case 'inspect':
-                    result = access.inspect();
-                    break;
-                case 'preview-consent':
-                    result = access.previewConsent(input);
-                    break;
-                case 'consent': {
-                    const p = input;
-                    result = access.consent(p.grant, authority, p.now);
-                    break;
-                }
-                case 'preview-revocation':
-                    result = access.previewRevocation(input);
-                    break;
-                case 'revoke': {
-                    const p = input;
-                    access.revoke(p.id, authority, p.now);
-                    result = { recorded: true };
-                    break;
-                }
-                case 'facts': {
-                    const p = input;
-                    result = readFixedOrderFacts(access.inspect().policy.archiveRoot, p.manifestId, { directory: state, purpose: p.purpose }, p.expected, p.now);
-                    break;
-                }
-                default: throw Error('unsupported access operation; raw read/export is not a CLI operation');
-            }
-        }
-    }
-    else if (args._[0] === 'weekly') {
-        if (request.operation === 'create') {
-            result = createWeeklyInvestigation(state, input).inspect();
-        }
-        else {
-            const job = openWeeklyInvestigation(state);
-            switch (request.operation) {
-                case 'inspect':
-                    result = job.inspect();
-                    break;
-                case 'run':
-                    result = job.run(request.input);
-                    break;
-                case 'approve':
-                    result = job.approve(authority);
-                    break;
-                case 'preview': {
-                    const p = request.input;
-                    result = job.preview(p.specPath, p.scenario);
-                    break;
-                }
-                case 'promote':
-                    result = job.promote(input, authority);
-                    break;
-                case 'freeze':
-                    result = job.freeze(input, authority);
-                    break;
-                case 'preview-edit':
-                    result = job.previewEdit(input);
-                    break;
-                case 'edit':
-                    result = job.edit(input, authority);
-                    break;
-                case 'evaluation':
-                    result = job.evaluation();
-                    break;
-                case 'preview-screen':
-                    result = job.previewScreen(input);
-                    break;
-                case 'screen':
-                    result = job.screen(input, authority);
-                    break;
-                default: throw Error('unsupported weekly operation');
-            }
-        }
-    }
-    else if (args._[0] === 'trust') {
-        if (request.operation === 'create') {
-            result = createTrustLifecycle(state, input, authority).inspect(0);
-        }
-        else {
-            const job = openTrustLifecycle(state);
-            switch (request.operation) {
-                case 'inspect':
-                    result = job.inspect(input);
-                    break;
-                case 'predict':
-                    job.predict(input);
-                    result = { recorded: true };
-                    break;
-                case 'correct': {
-                    const p = request.input;
-                    job.correct(p.prior, p.prediction, p.reason);
-                    result = { recorded: true };
-                    break;
-                }
-                case 'outcome':
-                    job.outcome(input, authority);
-                    result = { recorded: true };
-                    break;
-                case 'expose': {
-                    const p = request.input;
-                    result = job.expose(p.id, p.now);
-                    break;
-                }
-                default: throw Error('unsupported trust operation');
-            }
-        }
-    }
-    else
-        throw Error('unsupported learning family');
-    console.log(JSON.stringify(result, null, 2));
-}
-//# sourceMappingURL=archive-learning.js.map

package/dist/archive.d.ts

@@ -1,3 +0,0 @@
-import type { Args } from "./cli.js";
-/** Explicit file ingestion/metadata inspection only; never launches a worker or publishes content. */
-export declare function cmdArchive(args: Args): Promise<void>;

package/dist/archive.js

@@ -1,52 +0,0 @@
-import { ingestPolicySource, inspectPolicyCheckpoint, observeArchiveSource } from "@skill-harness/adapters";
-import { cmdArchiveLearning } from "./archive-learning.js";
-/** Explicit file ingestion/metadata inspection only; never launches a worker or publishes content. */
-export async function cmdArchive(args) {
-    const operation = args._[0];
-    if (operation === "weekly" || operation === "trust" || operation === "access") {
-        cmdArchiveLearning(args);
-        return;
-    }
-    if (operation === "watch") {
-        if (args._.length !== 1 || Object.keys(args.flags).some(key => !["policy", "source", "previous", "interval-ms", "max-polls"].includes(key)))
-            throw new Error("unsupported archive watch option");
-        const required = (key) => { const value = args.flags[key]; if (typeof value !== "string" || !value)
-            throw new Error(`archive watch requires --${key}`); return value; };
-        const signal = new AbortController(), abort = () => signal.abort();
-        process.on("SIGINT", abort);
-        process.on("SIGTERM", abort);
-        try {
-            const result = await observeArchiveSource({ policyPath: required("policy"), sourceId: required("source"),
-                previousCheckpointId: args.flags.previous === undefined ? undefined : required("previous"),
-                intervalMs: args.flags["interval-ms"] === undefined ? 1000 : Number(required("interval-ms")), maxPolls: Number(required("max-polls")), signal: signal.signal,
-                onObservation: observation => console.log(JSON.stringify({ checkpointId: observation.checkpointId, policySha256: observation.policySha256, syntax: observation.syntax })),
-            });
-            console.log(JSON.stringify(result));
-        }
-        finally {
-            process.removeListener("SIGINT", abort);
-            process.removeListener("SIGTERM", abort);
-        }
-        return;
-    }
-    if (args._.length !== 1 || !["ingest", "inspect"].includes(operation)) {
-        throw new Error("usage: archive ingest|inspect --policy <file> --source <id> [--previous <checkpoint> | --checkpoint <id>]");
-    }
-    const allowed = operation === "ingest" ? ["policy", "source", "previous"] : ["policy", "source", "checkpoint"];
-    for (const key of Object.keys(args.flags))
-        if (!allowed.includes(key))
-            throw new Error(`unsupported archive option: ${key}`);
-    const required = (key) => {
-        const value = args.flags[key];
-        if (typeof value !== "string" || !value)
-            throw new Error(`archive requires --${key}`);
-        return value;
-    };
-    const policy = required("policy"), source = required("source");
-    const result = operation === "ingest"
-        ? ingestPolicySource(policy, source, args.flags.previous === undefined ? undefined : required("previous"))
-        : inspectPolicyCheckpoint(policy, source, required("checkpoint"));
-    // Successful storage/reporting is not successful work: missing/partial fields are never promoted to acceptance.
-    console.log(JSON.stringify(result, null, 2));
-}
-//# sourceMappingURL=archive.js.map

package/dist/compare.d.ts

@@ -1,26 +0,0 @@
-import { buildComparison, type ComparisonThresholds, type HarnessAdapter, type RunMode } from "@skill-harness/core";
-export interface CompareCommandOptions {
-    target: string;
-    reference: string;
-    candidateRoot: string;
-    models: string[];
-    judgeToken: string;
-    mode: RunMode;
-    reps: number;
-    passThreshold: number;
-    parallel: number;
-    only?: string[];
-    canary?: boolean;
-    output?: string;
-    thresholds?: ComparisonThresholds;
-    adapter: HarnessAdapter;
-    now: () => string;
-    log?: (line: string) => void;
-}
-export interface CompareCommandResult {
-    outputDir: string;
-    reports: ReturnType<typeof buildComparison>[];
-    exitCode: 0 | 1 | 2;
-}
-/** Execute the same immutable plan against reference and candidate snapshots. */
-export declare function runCompareCommand(options: CompareCommandOptions): Promise<CompareCommandResult>;

package/dist/compare.js

@@ -1,232 +0,0 @@
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { tmpdir } from "node:os";
-import { dirname, join, relative, resolve, sep } from "node:path";
-import { execFileSync } from "node:child_process";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import { dump as yamlDump } from "js-yaml";
-import { buildComparison, comparisonExitCode, discover, fileSha256, FIXTURE_PREFIX, formatComparison, HARNESS_VERSION, loadSpec, modelSlug, parseModelRef, resolveSkill, runSkillModel, SKILL_KEY, SKILL_PROMPT_KEY, sourceHashes, } from "@skill-harness/core";
-/** Execute the same immutable plan against reference and candidate snapshots. */
-export async function runCompareCommand(options) {
-    const log = options.log ?? console.log;
-    const temp = mkdtempSync(join(tmpdir(), "skill-harness-compare-"));
-    try {
-        const candidate = snapshotExisting(options.candidateRoot, join(temp, "candidate"));
-        const reference = existsSync(options.reference)
-            ? snapshotExisting(options.reference, join(temp, "reference"))
-            : snapshotGitRef(options.candidateRoot, options.reference, join(temp, "reference"));
-        const candidateSkills = options.target === "all"
-            ? discover(candidate.skillsRoot).filter((skill) => skill.hasSpec)
-            : [resolveSkill(candidate.skillsRoot, options.target)];
-        const referenceSkills = new Map((options.target === "all"
-            ? discover(reference.skillsRoot).filter((skill) => skill.hasSpec)
-            : [resolveSkill(reference.skillsRoot, options.target)])
-            .map((skill) => [skill.name, skill]));
-        if (!candidateSkills.length)
-            throw new Error(`no candidate skills with specs under ${options.candidateRoot}`);
-        const outputDir = resolve(options.output ?? join(options.candidateRoot, ".skill-harness", "comparisons", timestampSlug(options.now())));
-        mkdirSync(outputDir, { recursive: true });
-        const reports = [];
-        const fixtures = (sources) => Object.fromEntries(Object.entries(sources).filter(([key]) => key.startsWith(FIXTURE_PREFIX)));
-        const inputs = (sources) => Object.fromEntries(Object.entries(sources).filter(([key]) => key !== SKILL_KEY && key !== SKILL_PROMPT_KEY));
-        // Materialize and validate the ENTIRE skill × model plan before the first
-        // paid call. `compare all` must not spend on skill 1 and only then discover
-        // that skill 7 is not a valid pair.
-        const plans = candidateSkills.map((candidateSkill) => {
-            const referenceSkill = referenceSkills.get(candidateSkill.name);
-            if (!referenceSkill)
-                throw new Error(`reference has no matching skill \`${candidateSkill.name}\``);
-            const candidateSpec = loadSpec(candidateSkill.specPath);
-            const referenceSpec = loadSpec(referenceSkill.specPath);
-            const candidateIds = candidateSpec.scenarios.map((scenario) => scenario.id).sort();
-            const referenceIds = referenceSpec.scenarios.map((scenario) => scenario.id).sort();
-            if (JSON.stringify(candidateIds) !== JSON.stringify(referenceIds))
-                throw new Error(`${candidateSkill.name}: reference/candidate scenario IDs differ`);
-            const refSpecDigest = fileSha256(referenceSkill.specPath);
-            const candSpecDigest = fileSha256(candidateSkill.specPath);
-            if (!refSpecDigest || !candSpecDigest || refSpecDigest !== candSpecDigest) {
-                throw new Error(`${candidateSkill.name}: reference/candidate specification.yaml differs — paired comparison changes only the skill under test`);
-            }
-            const refSources = sourceHashes({ skillDir: referenceSkill.dir, specDir: dirname(referenceSkill.specPath), scenarios: referenceSpec.scenarios, judgePersona: referenceSpec.judge_persona });
-            const candSources = sourceHashes({ skillDir: candidateSkill.dir, specDir: dirname(candidateSkill.specPath), scenarios: candidateSpec.scenarios, judgePersona: candidateSpec.judge_persona });
-            if (JSON.stringify(Object.entries(inputs(refSources)).sort()) !== JSON.stringify(Object.entries(inputs(candSources)).sort())) {
-                throw new Error(`${candidateSkill.name}: reference/candidate fixtures or other test inputs differ — refusing before model calls`);
-            }
-            return { candidateSkill, referenceSkill, candidateSpec, referenceSpec, refSpecDigest, candSpecDigest, refSources, candSources };
-        });
-        const modelPlans = options.models.map((token) => ({ token, model: parseModelRef(token) }));
-        const judge = parseModelRef(options.judgeToken);
-        for (const { candidateSkill, referenceSkill, candidateSpec, referenceSpec, refSpecDigest, candSpecDigest, refSources, candSources } of plans) {
-            for (const { token: modelToken, model } of modelPlans) {
-                log(`\n▶ compare ${candidateSkill.name} · ${modelToken} · reference then candidate`);
-                const timestamp = options.now();
-                const referenceRun = await runSkillModel({
-                    spec: referenceSpec,
-                    skillDir: referenceSkill.dir,
-                    specPath: referenceSkill.specPath,
-                    adapter: options.adapter,
-                    model,
-                    modelToken,
-                    judge,
-                    mode: options.mode,
-                    timestamp,
-                    label: "compare-reference",
-                    concurrency: options.parallel,
-                    reps: options.reps,
-                    passThreshold: options.passThreshold,
-                    only: options.only,
-                    canary: options.canary,
-                    onProgress: (line) => log(`  reference ${line}`),
-                });
-                const candidateRun = await runSkillModel({
-                    spec: candidateSpec,
-                    skillDir: candidateSkill.dir,
-                    specPath: candidateSkill.specPath,
-                    adapter: options.adapter,
-                    model,
-                    modelToken,
-                    judge,
-                    mode: options.mode,
-                    timestamp,
-                    label: "compare-candidate",
-                    concurrency: options.parallel,
-                    reps: options.reps,
-                    passThreshold: options.passThreshold,
-                    only: options.only,
-                    canary: options.canary,
-                    onProgress: (line) => log(`  candidate ${line}`),
-                });
-                const digests = {
-                    reference: {
-                        skill: mustDigest(join(referenceSkill.dir, "SKILL.md")),
-                        spec: refSpecDigest,
-                        fixtures: fixtures(refSources),
-                        inputs: inputs(refSources),
-                    },
-                    candidate: {
-                        skill: mustDigest(join(candidateSkill.dir, "SKILL.md")),
-                        spec: candSpecDigest,
-                        fixtures: fixtures(candSources),
-                        inputs: inputs(candSources),
-                    },
-                    harness: runtimeHarnessDigest(),
-                    model: sha256(modelToken),
-                    judge: sha256(options.judgeToken),
-                    environment: {
-                        node: process.version,
-                        platform: process.platform,
-                        arch: process.arch,
-                        harness_version: HARNESS_VERSION,
-                        harness_cli_reference: referenceRun.results.harness_cli_version ?? "unavailable",
-                        harness_cli_candidate: candidateRun.results.harness_cli_version ?? "unavailable",
-                    },
-                };
-                const report = buildComparison({
-                    skill: candidateSpec.skill,
-                    model: modelToken,
-                    mode: options.mode,
-                    reps: options.reps,
-                    judge: options.judgeToken,
-                    reference: referenceRun.results,
-                    candidate: candidateRun.results,
-                    critical: candidateSpec.critical,
-                    digests,
-                    partial: Boolean(options.only?.length),
-                    thresholds: options.thresholds,
-                });
-                reports.push(report);
-                const cellDir = join(outputDir, candidateSkill.name, modelSlug(model));
-                mkdirSync(cellDir, { recursive: true });
-                cpSync(referenceRun.runDir, join(cellDir, "reference"), { recursive: true });
-                cpSync(candidateRun.runDir, join(cellDir, "candidate"), { recursive: true });
-                writeFileSync(join(cellDir, "comparison.yaml"), yamlDump(report, { lineWidth: 120 }), "utf8");
-                writeFileSync(join(cellDir, "comparison.txt"), `${formatComparison(report)}\n`, "utf8");
-                log(`\n${formatComparison(report)}\n  artifacts: ${cellDir}`);
-            }
-        }
-        const exitCode = reports.reduce((highest, report) => Math.max(highest, comparisonExitCode(report)), 0);
-        return { outputDir, reports, exitCode };
-    }
-    finally {
-        rmSync(temp, { recursive: true, force: true });
-    }
-}
-function snapshotExisting(skillsRoot, destination) {
-    const absolute = realpathSync(resolve(skillsRoot));
-    const repo = gitRoot(absolute);
-    const sourceRoot = repo ? realpathSync(repo) : absolute;
-    const inside = relativeInside(sourceRoot, absolute);
-    copyTree(sourceRoot, destination);
-    return { skillsRoot: join(destination, inside) };
-}
-function snapshotGitRef(candidateSkillsRoot, ref, destination) {
-    const absolute = realpathSync(resolve(candidateSkillsRoot));
-    const rawRepo = gitRoot(absolute);
-    const repo = rawRepo ? realpathSync(rawRepo) : null;
-    if (!repo)
-        throw new Error(`--reference ${ref} is not a directory and --candidate is not inside a git repository`);
-    execFileSync("git", ["clone", "--quiet", "--no-checkout", repo, destination], { stdio: ["ignore", "ignore", "pipe"] });
-    try {
-        execFileSync("git", ["checkout", "--quiet", "--detach", ref], { cwd: destination, stdio: ["ignore", "ignore", "pipe"] });
-    }
-    catch (error) {
-        throw new Error(`cannot materialize reference git ref \`${ref}\`: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return { skillsRoot: join(destination, relativeInside(repo, absolute)) };
-}
-function relativeInside(root, target) {
-    const rel = relative(root, target);
-    if (rel === ".." || rel.startsWith(`..${sep}`) || resolve(root, rel) !== target) {
-        throw new Error(`skills root ${target} is outside snapshot root ${root}`);
-    }
-    return rel;
-}
-function gitRoot(path) {
-    try {
-        return execFileSync("git", ["-C", path, "rev-parse", "--show-toplevel"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-    }
-    catch {
-        return null;
-    }
-}
-function copyTree(source, destination) {
-    cpSync(source, destination, {
-        recursive: true,
-        filter: (path) => {
-            const rel = relative(source, path).replace(/\\/g, "/");
-            if (!rel)
-                return true;
-            return !rel.split("/").some((part) => part === ".git" || part === "node_modules" || part === ".skill-harness") && !/(^|\/)tests\/results(\/|$)/.test(rel);
-        },
-    });
-}
-function mustDigest(path) { const digest = fileSha256(path); if (!digest)
-    throw new Error(`cannot digest ${path}`); return digest; }
-function sha256(value) { return createHash("sha256").update(value).digest("hex"); }
-function timestampSlug(value) { return value.replace(/[:.]/g, "-"); }
-function runtimeHarnessDigest() {
-    const hash = createHash("sha256").update(`skill-harness/${HARNESS_VERSION}\0`);
-    const require = createRequire(import.meta.url);
-    const cliDir = dirname(fileURLToPath(import.meta.url));
-    const roots = [
-        cliDir,
-        join(dirname(cliDir), "assets"),
-        dirname(require.resolve("@skill-harness/core")),
-        dirname(require.resolve("@skill-harness/adapters")),
-    ].filter((root, index, all) => existsSync(root) && all.indexOf(root) === index);
-    if (!roots.length)
-        throw new Error("cannot locate running harness artifacts for comparison digest");
-    roots.forEach((root, rootIndex) => {
-        for (const file of filesUnder(root).sort()) {
-            hash.update(`${rootIndex}/${relative(root, file).replace(/\\/g, "/")}`).update("\0").update(readFileSync(file)).update("\0");
-        }
-    });
-    return hash.digest("hex");
-}
-function filesUnder(path) {
-    if (statSync(path).isFile())
-        return [path];
-    return readdirSync(path, { withFileTypes: true }).flatMap((entry) => entry.isDirectory() ? filesUnder(join(path, entry.name)) : entry.isFile() ? [join(path, entry.name)] : []);
-}
-//# sourceMappingURL=compare.js.map

package/dist/learning.d.ts

@@ -1,26 +0,0 @@
-import { openLearningWorkspace } from '@skill-harness/adapters';
-export interface LearningUI {
-    select(title: string, choices: string[]): Promise<string | undefined>;
-    input(title: string, initial?: string): Promise<string | undefined>;
-    editor(title: string, text: string): Promise<string | undefined>;
-    confirm(title: string, detail: string): Promise<boolean>;
-    notify(text: string, level?: 'info' | 'warning' | 'error'): void;
-}
-export declare const LEARNING_HELP = "Learning \u2014 retained evidence, no model calls\n  learning                         open guided review (interactive terminal)\n  learning init --archive DIR --author NAME [--scope-item N] --confirm\n      [--scope TEXT --population TEXT only for a comparison-only archive without retained cases]\n  learning status [--json]          readiness; never automatic exposure\n  learning import                  list retained batches/comparisons\n  learning import --item N --name NAME --title TEXT --scope-note TEXT --confirm\n  learning cases NAME [--offset N]\n  learning evidence NAME --item N [--evidence N]   inspect only the selected case's retained sources\n  learning case NAME --item N --disposition confirmed_defect|expected_behavior|exemplar|uncertain|skip --note TEXT --confirm\n  learning comparisons\n  learning review NAME             guided complete-output review in a terminal\n  learning artifact NAME --variant A [--artifact N]\n  learning choose NAME --kind one|tie|none|insufficient [--variants A,B] --full-review --note TEXT --confirm\n  learning reveal NAME             requires durable full-scope quality receipt\n  learning decide NAME --disposition adopt|reject|defer --note TEXT --confirm\n  learning hypothesis NAME --name SLUG --intervention TEXT --prediction TEXT --disproof TEXT --downside TEXT --rollback TEXT --alternative TEXT --confirm\n  learning link NAME --cases BATCH --item N --hypothesis SLUG --confirm\n  learning trust sample FILE --name SLUG --title TEXT [--split calibration|heldout|tuning] --confirm\n  learning trust setup --cases NAME [--detector ID] [--split calibration|heldout|tuning] [--max-unflagged N]\n      [--attention N --minimum-resolved N --minimum-lower-bound T --expires DAYS] --confirm\n  learning trust status\n  learning trust label --cases NAME --item N --reference-author NAME --confirm\n  learning trust unflagged --item N --miss yes|no --evidence FILE --reference-author NAME --note TEXT --confirm\n  learning adoption NAME           scope/decision/readiness; activation is producer-owned\n  learning outcome NAME            inspect observed outcomes\n  learning outcome NAME --result success|confirmed-defect|unknown --artifact FILE --original-requirement FILE --current-requirement FILE --evidence FILE --reference-author NAME --note TEXT [--accepted-artifact FILE --acceptance-evidence FILE] --confirm\n  learning guide | current         installed portable guide / requirement register\nAll commands accept --state DIR (default .skill-harness/learning), --json for structured output.\n--confirm authorizes only the displayed local write, never models, acceptance or registry activation.\nNo raw manifest authoring. Import selects actual retained inputs. Exit zero is command completion, not quality.\nRegistry activation/rollback use /grants learning in interactive Pi, with independent authority.";
-/** Escape terminal control/format characters in untrusted retained display text. Exact archive
- * bytes never change; output honestly identifies this as a display representation. */
-export declare function learningDisplay(text: string): string;
-export declare function formatLearningStatus(view: ReturnType<ReturnType<typeof openLearningWorkspace>['inspect']>): string;
-export declare function formatLearningTrust(trust: Record<string, unknown>): string;
-export interface LearningCommandOptions {
-    cwd?: string;
-    write?: (text: string) => void;
-    ui?: LearningUI;
-}
-export declare function runLearningCommand(argv: string[], options?: LearningCommandOptions): Promise<unknown>;
-export declare function reviewLearningComparison(directory: string, name: string, ui: LearningUI): Promise<void>;
-export declare function runLearningWizard(options: {
-    cwd: string;
-    directory: string;
-    ui: LearningUI;
-}): Promise<void>;