hippo-memory 1.71.0 → 2.0.0

package/dist/cli/playbooks.js

@@ -1,17 +1,12 @@
 // First-class object verbs for processes, policies and skills.
-import { extractPathTags } from '../search/path-context.js';
 import * as processesModule from '../objects/processes.js';
 import * as policiesModule from '../objects/policies.js';
 import * as skillsModule from '../objects/skills.js';
 import { printError } from './output.js';
-import { isStringFlag, nonEmptyStringFlag, stringFlag } from './flag-values.js';
-import { requireInit } from './shared.js';
-import { closeObject, foundOrExit, idArgOrExit, listObjects, printLifecycleTail } from './object-verbs.js';
+import { isStringFlag, nonEmptyStringFlag } from './flag-values.js';
 import { errorMessage } from '../util/log.js';
 import { CliExit } from './exit.js';
-const PROCESS = { cmd: 'process', noun: 'Process', idLabel: 'process' };
-const POLICY = { cmd: 'policy', noun: 'Policy', idLabel: 'policy' };
-const SKILL = { cmd: 'skill', noun: 'Skill', idLabel: 'skill' };
+import { requiredText, versionedVerbs } from './versioned-verbs.js';
 // --step is a repeatable flag (collected into an array by parseArgs). A single
 // --step yields a string; normalize both to string[]. A value-less --step errors.
 function collectProcessSteps(stepRaw) {
@@ -31,109 +26,55 @@ function printProcessRow(proc) {
     if (proc.changeSummary)
         console.log(`    change: ${proc.changeSummary}`);
 }
-function processList(hippoRoot, tenantId, flags) {
-    listObjects(flags, {
-        plural: 'processes',
-        states: processesModule.VALID_PROCESS_STATES,
-        load: (opts) => processesModule.loadProcesses(hippoRoot, tenantId, opts),
-        printRow: printProcessRow,
-    });
-}
-function processGet(hippoRoot, tenantId, args) {
-    const id = idArgOrExit(args, 'Usage: hippo process get <id>', PROCESS.idLabel);
-    const proc = foundOrExit(processesModule.loadProcessById(hippoRoot, tenantId, id), PROCESS.noun, id);
-    console.log(`Process #${proc.id}`);
-    console.log(`  name: ${proc.processName}`);
-    console.log(`  status: ${proc.status}`);
-    console.log(`  version: ${proc.version}`);
-    if (proc.description)
-        console.log(`  description: ${proc.description}`);
-    if (proc.steps.length > 0) {
-        console.log(`  steps:`);
-        proc.steps.forEach((s, i) => console.log(`    ${i + 1}. ${s}`));
-    }
-    printLifecycleTail(proc);
-}
-function processSupersede(hippoRoot, tenantId, args, flags) {
-    const id = idArgOrExit(args, 'Usage: hippo process supersede <id> --step "<text>" [--step ...] [--change "<summary>"] [--description "<text>"]', PROCESS.idLabel);
-    const steps = collectProcessSteps(flags['step']);
-    if (steps.length === 0) {
-        printError('hippo process supersede requires at least one --step "<text>" for the new version.');
-        throw new CliExit(1);
-    }
-    // A supersession is a new version of the SAME process, so the new row reuses the predecessor's name; loadProcessById gives an early not-found,
-    // and saveProcess's in-SAVEPOINT preflight is the authoritative active-state check.
-    const existing = foundOrExit(processesModule.loadProcessById(hippoRoot, tenantId, id), PROCESS.noun, id);
-    const changeSummary = nonEmptyStringFlag(flags, 'change');
-    const description = nonEmptyStringFlag(flags, 'description');
-    const procPathTags = extractPathTags(process.cwd());
-    const created = processesModule.saveProcess(hippoRoot, tenantId, {
-        processName: existing.processName,
-        steps,
-        description,
-        changeSummary,
-        supersedesProcessId: id,
-        extraTags: procPathTags,
-    });
-    console.log(`Process #${created.id} recorded (v${created.version}), superseding #${id}.`);
-    if (created.memoryId)
-        console.log(`  memory: ${created.memoryId}`);
-}
-function processClose(hippoRoot, tenantId, args) {
-    closeObject(args, PROCESS, (id) => processesModule.closeProcess(hippoRoot, tenantId, id));
-}
-export function handleProcess({ hippoRoot, tenantId, args, flags }) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? '';
-    if (subcommand === 'list')
-        return processList(hippoRoot, tenantId, flags);
-    if (subcommand === 'get')
-        return processGet(hippoRoot, tenantId, args);
-    if (subcommand === 'supersede')
-        return processSupersede(hippoRoot, tenantId, args, flags);
-    if (subcommand === 'close')
-        return processClose(hippoRoot, tenantId, args);
-    // Default subcommand is new (create): accept both `process new "<name>"` and bare `process "<name>"`;
-    // for the `new` keyword the name is args[1], otherwise args[0] is the name.
-    processCreate(hippoRoot, tenantId, subcommand === 'new' ? (args[1] ?? '') : subcommand, flags);
-}
-function processCreate(hippoRoot, tenantId, processName, flags) {
-    if (!processName) {
-        printError('Usage: hippo process new "<name>" --step "<text>" [--step ...] [--description "<text>"]');
-        printError('       hippo process list [--status active|superseded|closed|all] [--limit N]');
-        printError('       hippo process get <id>');
-        printError('       hippo process supersede <id> --step "<text>" [--change "<summary>"]');
-        printError('       hippo process close <id>');
-        throw new CliExit(1);
-    }
-    const steps = collectProcessSteps(flags['step']);
-    const description = nonEmptyStringFlag(flags, 'description');
-    const procPathTags = extractPathTags(process.cwd());
-    const created = processesModule.saveProcess(hippoRoot, tenantId, {
-        processName,
-        steps,
-        description,
-        extraTags: procPathTags,
-    });
-    console.log(`Process recorded: #${created.id} (v${created.version}, ${created.steps.length} steps)`);
-    if (created.memoryId)
-        console.log(`  memory: ${created.memoryId}`);
-}
+const processKind = (hippoRoot, tenantId) => ({
+    names: { cmd: 'process', noun: 'Process', idLabel: 'process' },
+    plural: 'processes',
+    states: processesModule.VALID_PROCESS_STATES,
+    usage: [
+        'Usage: hippo process new "<name>" --step "<text>" [--step ...] [--description "<text>"]',
+        '       hippo process list [--status active|superseded|closed|all] [--limit N]',
+        '       hippo process get <id>',
+        '       hippo process supersede <id> --step "<text>" [--change "<summary>"]',
+        '       hippo process close <id>',
+    ],
+    supersedeUsage: 'Usage: hippo process supersede <id> --step "<text>" [--step ...] [--change "<summary>"] [--description "<text>"]',
+    bodyRequired: 'at least one --step "<text>"',
+    body: (flags, verb) => {
+        const steps = collectProcessSteps(flags['step']);
+        // A new process may start with no steps; a new version must say what its steps are.
+        if (verb === 'supersede' && steps.length === 0)
+            return undefined;
+        return { steps, description: nonEmptyStringFlag(flags, 'description') };
+    },
+    keyOf: (proc) => proc.processName,
+    save: (processName, body, extraTags, from) => processesModule.saveProcess(hippoRoot, tenantId, {
+        processName, ...body, extraTags, changeSummary: from?.changeSummary, supersedesProcessId: from?.id,
+    }),
+    recorded: (proc) => `Process recorded: #${proc.id} (v${proc.version}, ${proc.steps.length} steps)`,
+    list: (opts) => processesModule.loadProcesses(hippoRoot, tenantId, opts),
+    loadById: (id) => processesModule.loadProcessById(hippoRoot, tenantId, id),
+    close: (id) => processesModule.closeProcess(hippoRoot, tenantId, id),
+    printRow: printProcessRow,
+    printDetail: (proc) => {
+        console.log(`  name: ${proc.processName}`);
+        console.log(`  status: ${proc.status}`);
+        console.log(`  version: ${proc.version}`);
+        if (proc.description)
+            console.log(`  description: ${proc.description}`);
+        if (proc.steps.length > 0) {
+            console.log(`  steps:`);
+            proc.steps.forEach((s, i) => console.log(`    ${i + 1}. ${s}`));
+        }
+    },
+});
+export const handleProcess = versionedVerbs(processKind);
+const policyRange = (p) => (p.validTo ? `${p.validFrom}..${p.validTo}` : `${p.validFrom}..(open)`);
 function printPolicyRow(p) {
-    const range = p.validTo ? `${p.validFrom}..${p.validTo}` : `${p.validFrom}..(open)`;
-    console.log(`#${p.id} [${p.status}] v${p.version} ${range} memory=${p.memoryId ?? '-'}`);
+    console.log(`#${p.id} [${p.status}] v${p.version} ${policyRange(p)} memory=${p.memoryId ?? '-'}`);
     console.log(`    ${p.policyName}: ${p.policyText}`);
     if (p.changeSummary)
         console.log(`    change: ${p.changeSummary}`);
 }
-function policyList(hippoRoot, tenantId, flags) {
-    listObjects(flags, {
-        plural: 'policies',
-        states: policiesModule.VALID_POLICY_STATES,
-        load: (opts) => policiesModule.loadPolicies(hippoRoot, tenantId, opts),
-        printRow: printPolicyRow,
-    });
-}
 function policyAsOf(hippoRoot, tenantId, args, flags) {
     const dateRaw = args[1];
     if (!dateRaw) {
@@ -157,96 +98,46 @@ function policyAsOf(hippoRoot, tenantId, args, flags) {
     for (const p of results)
         printPolicyRow(p);
 }
-function policyGet(hippoRoot, tenantId, args) {
-    const id = idArgOrExit(args, 'Usage: hippo policy get <id>', POLICY.idLabel);
-    const p = foundOrExit(policiesModule.loadPolicyById(hippoRoot, tenantId, id), POLICY.noun, id);
-    console.log(`Policy #${p.id}`);
-    console.log(`  name: ${p.policyName}`);
-    console.log(`  text: ${p.policyText}`);
-    console.log(`  status: ${p.status}`);
-    console.log(`  version: ${p.version}`);
-    console.log(`  valid_from: ${p.validFrom}`);
-    console.log(`  valid_to: ${p.validTo ?? '(open-ended)'}`);
-    printLifecycleTail(p);
-}
-function policySupersede(hippoRoot, tenantId, args, flags) {
-    const id = idArgOrExit(args, 'Usage: hippo policy supersede <id> --text "<rule>" [--from <iso>] [--to <iso>] [--change "<summary>"]', POLICY.idLabel);
-    const textRaw = stringFlag(flags, 'text');
-    if (!textRaw?.trim()) {
-        printError('hippo policy supersede requires --text "<rule>" for the new version.');
-        throw new CliExit(1);
-    }
-    const existing = foundOrExit(policiesModule.loadPolicyById(hippoRoot, tenantId, id), POLICY.noun, id);
-    try {
-        const created = policiesModule.savePolicy(hippoRoot, tenantId, {
-            policyName: existing.policyName,
-            policyText: textRaw,
-            validFrom: nonEmptyStringFlag(flags, 'from'),
-            validTo: nonEmptyStringFlag(flags, 'to'),
-            changeSummary: nonEmptyStringFlag(flags, 'change'),
-            supersedesPolicyId: id,
-            extraTags: extractPathTags(process.cwd()),
-        });
-        console.log(`Policy #${created.id} recorded (v${created.version}), superseding #${id}.`);
-        if (created.memoryId)
-            console.log(`  memory: ${created.memoryId}`);
-    }
-    catch (e) {
-        printError(errorMessage(e));
-        throw new CliExit(1);
-    }
-}
-function policyClose(hippoRoot, tenantId, args) {
-    closeObject(args, POLICY, (id) => policiesModule.closePolicy(hippoRoot, tenantId, id));
-}
-export function handlePolicy({ hippoRoot, tenantId, args, flags }) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? '';
-    if (subcommand === 'list')
-        return policyList(hippoRoot, tenantId, flags);
-    if (subcommand === 'asof')
-        return policyAsOf(hippoRoot, tenantId, args, flags);
-    if (subcommand === 'get')
-        return policyGet(hippoRoot, tenantId, args);
-    if (subcommand === 'supersede')
-        return policySupersede(hippoRoot, tenantId, args, flags);
-    if (subcommand === 'close')
-        return policyClose(hippoRoot, tenantId, args);
-    policyCreate(hippoRoot, tenantId, args, flags);
-}
-function policyCreate(hippoRoot, tenantId, args, flags) {
-    const subcommand = args[0] ?? '';
-    // Default subcommand: new (create). Accept both `policy new "<name>"` and the
-    // bare `policy "<name>"` form: for the `new` keyword the name is args[1].
-    const policyName = subcommand === 'new' ? (args[1] ?? '') : subcommand;
-    const textRaw = stringFlag(flags, 'text');
-    if (!policyName || !textRaw?.trim()) {
-        printError('Usage: hippo policy new "<name>" --text "<rule>" [--from <iso>] [--to <iso>]');
-        printError('       hippo policy list [--status active|superseded|closed|all] [--limit N]');
-        printError('       hippo policy get <id>');
-        printError('       hippo policy asof <iso-date> [--name "<policy>"]');
-        printError('       hippo policy supersede <id> --text "<rule>" [--from] [--to] [--change "<summary>"]');
-        printError('       hippo policy close <id>');
-        throw new CliExit(1);
-    }
-    try {
-        const created = policiesModule.savePolicy(hippoRoot, tenantId, {
-            policyName,
-            policyText: textRaw,
-            validFrom: nonEmptyStringFlag(flags, 'from'),
-            validTo: nonEmptyStringFlag(flags, 'to'),
-            extraTags: extractPathTags(process.cwd()),
-        });
-        const range = created.validTo ? `${created.validFrom}..${created.validTo}` : `${created.validFrom}..(open)`;
-        console.log(`Policy recorded: #${created.id} (v${created.version}, effective ${range})`);
-        if (created.memoryId)
-            console.log(`  memory: ${created.memoryId}`);
-    }
-    catch (e) {
-        printError(errorMessage(e));
-        throw new CliExit(1);
-    }
-}
+const policyKind = (hippoRoot, tenantId) => ({
+    names: { cmd: 'policy', noun: 'Policy', idLabel: 'policy' },
+    plural: 'policies',
+    states: policiesModule.VALID_POLICY_STATES,
+    usage: [
+        'Usage: hippo policy new "<name>" --text "<rule>" [--from <iso>] [--to <iso>]',
+        '       hippo policy list [--status active|superseded|closed|all] [--limit N]',
+        '       hippo policy get <id>',
+        '       hippo policy asof <iso-date> [--name "<policy>"]',
+        '       hippo policy supersede <id> --text "<rule>" [--from] [--to] [--change "<summary>"]',
+        '       hippo policy close <id>',
+    ],
+    supersedeUsage: 'Usage: hippo policy supersede <id> --text "<rule>" [--from <iso>] [--to <iso>] [--change "<summary>"]',
+    bodyRequired: '--text "<rule>"',
+    body: (flags) => {
+        const policyText = requiredText(flags, 'text');
+        if (policyText === undefined)
+            return undefined;
+        return { policyText, validFrom: nonEmptyStringFlag(flags, 'from'), validTo: nonEmptyStringFlag(flags, 'to') };
+    },
+    keyOf: (p) => p.policyName,
+    save: (policyName, body, extraTags, from) => policiesModule.savePolicy(hippoRoot, tenantId, {
+        policyName, ...body, extraTags, changeSummary: from?.changeSummary, supersedesPolicyId: from?.id,
+    }),
+    recorded: (p) => `Policy recorded: #${p.id} (v${p.version}, effective ${policyRange(p)})`,
+    list: (opts) => policiesModule.loadPolicies(hippoRoot, tenantId, opts),
+    loadById: (id) => policiesModule.loadPolicyById(hippoRoot, tenantId, id),
+    close: (id) => policiesModule.closePolicy(hippoRoot, tenantId, id),
+    printRow: printPolicyRow,
+    printDetail: (p) => {
+        console.log(`  name: ${p.policyName}`);
+        console.log(`  text: ${p.policyText}`);
+        console.log(`  status: ${p.status}`);
+        console.log(`  version: ${p.version}`);
+        console.log(`  valid_from: ${p.validFrom}`);
+        console.log(`  valid_to: ${p.validTo ?? '(open-ended)'}`);
+    },
+    extra: { sub: 'asof', run: (args, flags) => policyAsOf(hippoRoot, tenantId, args, flags) },
+});
+export const handlePolicy = versionedVerbs(policyKind);
 function printSkillRow(s) {
     const trig = s.trigger ? ` when="${s.trigger}"` : '';
     console.log(`#${s.id} [${s.status}] v${s.version}${trig} memory=${s.memoryId ?? '-'}`);
@@ -254,14 +145,6 @@ function printSkillRow(s) {
     if (s.changeSummary)
         console.log(`    change: ${s.changeSummary}`);
 }
-function skillList(hippoRoot, tenantId, flags) {
-    listObjects(flags, {
-        plural: 'skills',
-        states: skillsModule.VALID_SKILL_STATES,
-        load: (opts) => skillsModule.loadSkills(hippoRoot, tenantId, opts),
-        printRow: printSkillRow,
-    });
-}
 function skillExport(hippoRoot, tenantId) {
     const md = skillsModule.exportSkills(hippoRoot, tenantId);
     if (!md) {
@@ -270,91 +153,44 @@ function skillExport(hippoRoot, tenantId) {
     }
     console.log(md);
 }
-function skillGet(hippoRoot, tenantId, args) {
-    const id = idArgOrExit(args, 'Usage: hippo skill get <id>', SKILL.idLabel);
-    const s = foundOrExit(skillsModule.loadSkillById(hippoRoot, tenantId, id), SKILL.noun, id);
-    console.log(`Skill #${s.id}`);
-    console.log(`  name: ${s.skillName}`);
-    console.log(`  status: ${s.status}`);
-    console.log(`  version: ${s.version}`);
-    if (s.trigger)
-        console.log(`  when: ${s.trigger}`);
-    console.log(`  instructions: ${s.instructions}`);
-    printLifecycleTail(s);
-}
-function skillSupersede(hippoRoot, tenantId, args, flags) {
-    const id = idArgOrExit(args, 'Usage: hippo skill supersede <id> --instructions "<text>" [--trigger "<when>"] [--change "<summary>"]', SKILL.idLabel);
-    const instrRaw = stringFlag(flags, 'instructions');
-    if (!instrRaw?.trim()) {
-        printError('hippo skill supersede requires --instructions "<text>" for the new version.');
-        throw new CliExit(1);
-    }
-    const existing = foundOrExit(skillsModule.loadSkillById(hippoRoot, tenantId, id), SKILL.noun, id);
-    try {
-        const created = skillsModule.saveSkill(hippoRoot, tenantId, {
-            skillName: existing.skillName,
-            instructions: instrRaw,
-            trigger: nonEmptyStringFlag(flags, 'trigger'),
-            changeSummary: nonEmptyStringFlag(flags, 'change'),
-            supersedesSkillId: id,
-            extraTags: extractPathTags(process.cwd()),
-        });
-        console.log(`Skill #${created.id} recorded (v${created.version}), superseding #${id}.`);
-        if (created.memoryId)
-            console.log(`  memory: ${created.memoryId}`);
-    }
-    catch (e) {
-        printError(errorMessage(e));
-        throw new CliExit(1);
-    }
-}
-function skillClose(hippoRoot, tenantId, args) {
-    closeObject(args, SKILL, (id) => skillsModule.closeSkill(hippoRoot, tenantId, id));
-}
-export function handleSkill({ hippoRoot, tenantId, args, flags }) {
-    requireInit(hippoRoot);
-    const subcommand = args[0] ?? '';
-    if (subcommand === 'list')
-        return skillList(hippoRoot, tenantId, flags);
-    if (subcommand === 'export')
-        return skillExport(hippoRoot, tenantId);
-    if (subcommand === 'get')
-        return skillGet(hippoRoot, tenantId, args);
-    if (subcommand === 'supersede')
-        return skillSupersede(hippoRoot, tenantId, args, flags);
-    if (subcommand === 'close')
-        return skillClose(hippoRoot, tenantId, args);
-    skillCreate(hippoRoot, tenantId, args, flags);
-}
-function skillCreate(hippoRoot, tenantId, args, flags) {
-    const subcommand = args[0] ?? '';
-    // Default subcommand: new (create). Accept both `skill new "<name>"` and the
-    // bare `skill "<name>"` form: for the `new` keyword the name is args[1].
-    const skillName = subcommand === 'new' ? (args[1] ?? '') : subcommand;
-    const instrRaw = stringFlag(flags, 'instructions');
-    if (!skillName || !instrRaw?.trim()) {
-        printError('Usage: hippo skill new "<name>" --instructions "<text>" [--trigger "<when>"]');
-        printError('       hippo skill list [--status active|superseded|closed|all] [--limit N]');
-        printError('       hippo skill get <id>');
-        printError('       hippo skill export   (render active skills as an AGENTS.md/CLAUDE.md block)');
-        printError('       hippo skill supersede <id> --instructions "<text>" [--trigger] [--change "<summary>"]');
-        printError('       hippo skill close <id>');
-        throw new CliExit(1);
-    }
-    try {
-        const created = skillsModule.saveSkill(hippoRoot, tenantId, {
-            skillName,
-            instructions: instrRaw,
-            trigger: nonEmptyStringFlag(flags, 'trigger'),
-            extraTags: extractPathTags(process.cwd()),
-        });
-        console.log(`Skill recorded: #${created.id} (v${created.version})`);
-        if (created.memoryId)
-            console.log(`  memory: ${created.memoryId}`);
-    }
-    catch (e) {
-        printError(errorMessage(e));
-        throw new CliExit(1);
-    }
-}
+const skillKind = (hippoRoot, tenantId) => ({
+    names: { cmd: 'skill', noun: 'Skill', idLabel: 'skill' },
+    plural: 'skills',
+    states: skillsModule.VALID_SKILL_STATES,
+    usage: [
+        'Usage: hippo skill new "<name>" --instructions "<text>" [--trigger "<when>"]',
+        '       hippo skill list [--status active|superseded|closed|all] [--limit N]',
+        '       hippo skill get <id>',
+        '       hippo skill export   (render active skills as an AGENTS.md/CLAUDE.md block)',
+        '       hippo skill supersede <id> --instructions "<text>" [--trigger] [--change "<summary>"]',
+        '       hippo skill close <id>',
+    ],
+    supersedeUsage: 'Usage: hippo skill supersede <id> --instructions "<text>" [--trigger "<when>"] [--change "<summary>"]',
+    bodyRequired: '--instructions "<text>"',
+    body: (flags) => {
+        const instructions = requiredText(flags, 'instructions');
+        if (instructions === undefined)
+            return undefined;
+        return { instructions, trigger: nonEmptyStringFlag(flags, 'trigger') };
+    },
+    keyOf: (s) => s.skillName,
+    save: (skillName, body, extraTags, from) => skillsModule.saveSkill(hippoRoot, tenantId, {
+        skillName, ...body, extraTags, changeSummary: from?.changeSummary, supersedesSkillId: from?.id,
+    }),
+    recorded: (s) => `Skill recorded: #${s.id} (v${s.version})`,
+    list: (opts) => skillsModule.loadSkills(hippoRoot, tenantId, opts),
+    loadById: (id) => skillsModule.loadSkillById(hippoRoot, tenantId, id),
+    close: (id) => skillsModule.closeSkill(hippoRoot, tenantId, id),
+    printRow: printSkillRow,
+    printDetail: (s) => {
+        console.log(`  name: ${s.skillName}`);
+        console.log(`  status: ${s.status}`);
+        console.log(`  version: ${s.version}`);
+        if (s.trigger)
+            console.log(`  when: ${s.trigger}`);
+        console.log(`  instructions: ${s.instructions}`);
+    },
+    extra: { sub: 'export', run: () => skillExport(hippoRoot, tenantId) },
+});
+export const handleSkill = versionedVerbs(skillKind);
 //# sourceMappingURL=playbooks.js.map

package/dist/cli/predictions.d.ts

@@ -0,0 +1,3 @@
+import { type CommandContext } from './flag-values.js';
+export declare function handlePredict({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
+//# sourceMappingURL=predictions.d.ts.map

package/dist/cli/predictions.js

@@ -0,0 +1,174 @@
+// First-class object verbs for predictions: record a claim, close it against the actual, and read the class base rate.
+import * as predictionsApi from '../api/predictions.js';
+import { VALID_CLOSURE_STATES } from '../core/prediction.js';
+import { cliApiContext } from './api-context.js';
+import { printError } from './output.js';
+import { parseListLimit, stringFlag } from './flag-values.js';
+import { requireInit } from './shared.js';
+import { foundOrExit, idArgOrExit, requireStatus } from './object-verbs.js';
+import { CliExit } from './exit.js';
+const BASERATE_DECIMALS = 3;
+const PREDICTION_NOUN = 'Prediction';
+async function predictClose(ctx, args, flags) {
+    const id = idArgOrExit(args, 'Usage: hippo predict close <id> --state <closed|closed-unknown> [--actual <v>] [--note "..."]', 'prediction');
+    const stateRaw = (stringFlag(flags, 'state') ?? '').trim();
+    // SAFETY: Set.has only compares by value, so a string outside the closure states is a plain miss.
+    if (!VALID_CLOSURE_STATES.has(stateRaw) || stateRaw === 'open') {
+        printError(`Invalid --state: "${stateRaw}". Must be one of: closed | closed-unknown.`);
+        throw new CliExit(1);
+    }
+    const actualRaw = flags['actual'];
+    const actualValue = actualRaw !== undefined ? Number(actualRaw) : undefined;
+    if (actualRaw !== undefined && !Number.isFinite(actualValue)) {
+        printError(`Invalid --actual: "${actualRaw}". Must be a number.`);
+        throw new CliExit(1);
+    }
+    const closureNote = stringFlag(flags, 'note');
+    const closed = await predictionsApi.closePrediction(ctx, id, {
+        // SAFETY: the check above exits unless stateRaw is in VALID_CLOSURE_STATES and not open.
+        closureState: stateRaw,
+        actualValue,
+        closureNote,
+    });
+    console.log(`Prediction ${closed.id} closed: state=${closed.closureState}${closed.actualValue !== null ? ` actual=${closed.actualValue}` : ''}`);
+}
+async function loadPredictionList(ctx, status, classTag, limit) {
+    if (status === 'open') {
+        return predictionsApi.listPredictions(ctx, {
+            classTag: classTag || undefined,
+            closureState: 'open',
+            limit,
+        });
+    }
+    if (status === 'all') {
+        return predictionsApi.listPredictions(ctx, classTag ? { classTag, limit } : { limit });
+    }
+    const closureState = requireStatus(status, VALID_CLOSURE_STATES);
+    if (!classTag) {
+        // status filter without class: scan all classes is more complex; v1 requires --class for non-default status
+        printError('--status filter (non-open) requires --class to be set.');
+        throw new CliExit(1);
+    }
+    return predictionsApi.listPredictions(ctx, {
+        classTag,
+        closureState,
+        limit,
+    });
+}
+async function predictList(ctx, flags) {
+    const classTag = stringFlag(flags, 'class')?.trim() ?? '';
+    const status = stringFlag(flags, 'status')?.trim() ?? 'all';
+    const limit = parseListLimit(flags);
+    const results = await loadPredictionList(ctx, status, classTag, limit);
+    if (results.length === 0) {
+        console.log(classTag ? `No predictions in class "${classTag}".` : 'No predictions.');
+        return;
+    }
+    console.log(`Found ${results.length} predictions:\n`);
+    for (const p of results) {
+        const estPart = p.estimateValue !== null ? ` estimate=${p.estimateValue}${p.estimateUnit ? ` ${p.estimateUnit}` : ''}` : '';
+        const actPart = p.actualValue !== null ? ` actual=${p.actualValue}` : '';
+        const tgtPart = p.targetDate ? ` target=${p.targetDate}` : '';
+        console.log(`#${p.id} [${p.closureState}] class=${p.classTag}${estPart}${actPart}${tgtPart}`);
+        console.log(`    ${p.claimText}`);
+        if (p.closureNote)
+            console.log(`    note: ${p.closureNote}`);
+    }
+}
+async function predictShow(ctx, args) {
+    const id = idArgOrExit(args, 'Usage: hippo predict show <id>', 'prediction');
+    const pred = foundOrExit(await predictionsApi.predictionById(ctx, id), PREDICTION_NOUN, id);
+    console.log(`Prediction #${pred.id}`);
+    console.log(`  class: ${pred.classTag}`);
+    console.log(`  claim: ${pred.claimText}`);
+    console.log(`  state: ${pred.closureState}`);
+    if (pred.estimateValue !== null)
+        console.log(`  estimate: ${pred.estimateValue}${pred.estimateUnit ? ' ' + pred.estimateUnit : ''}`);
+    if (pred.targetDate)
+        console.log(`  target: ${pred.targetDate}`);
+    if (pred.actualValue !== null)
+        console.log(`  actual: ${pred.actualValue}`);
+    if (pred.closedAt)
+        console.log(`  closed: ${pred.closedAt}`);
+    if (pred.closureNote)
+        console.log(`  note: ${pred.closureNote}`);
+    if (pred.memoryId)
+        console.log(`  memory: ${pred.memoryId}`);
+    console.log(`  created: ${pred.createdAt}`);
+}
+async function predictBaserate(ctx, flags) {
+    // Reference-class / planning-fallacy detector
+    const classTag = stringFlag(flags, 'class')?.trim();
+    if (!classTag) {
+        printError('Usage: hippo predict baserate --class <c>');
+        throw new CliExit(1);
+    }
+    const baserate = await predictionsApi.predictionBaserate(ctx, classTag);
+    if (baserate.nClosed === 0) {
+        console.log(`No closed predictions in class "${baserate.classTag}" yet.`);
+        console.log(`  Create one with: hippo predict "<claim>" --class ${baserate.classTag} --estimate N`);
+        console.log(`  Close it later:  hippo predict close <id> --state closed --actual N`);
+        return;
+    }
+    console.log(baserate.summary);
+    console.log(`  n_closed:         ${baserate.nClosed}`);
+    console.log(`  n_ratio_eligible: ${baserate.nRatioEligible}`);
+    if (baserate.meanEstimate !== null)
+        console.log(`  mean_estimate:    ${baserate.meanEstimate.toFixed(BASERATE_DECIMALS)}`);
+    if (baserate.meanActual !== null)
+        console.log(`  mean_actual:      ${baserate.meanActual.toFixed(BASERATE_DECIMALS)}`);
+    if (baserate.meanRatio !== null)
+        console.log(`  mean_ratio:       ${baserate.meanRatio.toFixed(BASERATE_DECIMALS)}x`);
+    if (baserate.p50Ratio !== null)
+        console.log(`  p50_ratio:        ${baserate.p50Ratio.toFixed(BASERATE_DECIMALS)}x`);
+    if (baserate.mae !== null)
+        console.log(`  mae:              ${baserate.mae.toFixed(BASERATE_DECIMALS)}`);
+}
+export async function handlePredict({ hippoRoot, tenantId, args, flags }) {
+    requireInit(hippoRoot);
+    const ctx = cliApiContext(hippoRoot, tenantId);
+    const subcommand = args[0] ?? '';
+    if (subcommand === 'close')
+        return predictClose(ctx, args, flags);
+    if (subcommand === 'list')
+        return predictList(ctx, flags);
+    if (subcommand === 'show')
+        return predictShow(ctx, args);
+    if (subcommand === 'baserate')
+        return predictBaserate(ctx, flags);
+    // Default subcommand: create. args[0] is the claim text.
+    return predictCreate(ctx, subcommand, flags);
+}
+async function predictCreate(ctx, claimText, flags) {
+    if (!claimText) {
+        printError('Usage: hippo predict "<claim>" --class <c> [--estimate <v>] [--unit <u>] [--target <YYYY-MM-DD>]');
+        printError('       hippo predict close <id> --state <closed|closed-unknown> [--actual <v>] [--note "..."]');
+        printError('       hippo predict list [--class X] [--status open|closed|closed-unknown|all] [--limit N]');
+        printError('       hippo predict show <id>');
+        throw new CliExit(1);
+    }
+    const classTag = stringFlag(flags, 'class')?.trim();
+    if (!classTag) {
+        printError('--class is required for prediction creation.');
+        throw new CliExit(1);
+    }
+    const estimateRaw = flags['estimate'];
+    const estimateValue = estimateRaw !== undefined ? Number(estimateRaw) : undefined;
+    if (estimateRaw !== undefined && !Number.isFinite(estimateValue)) {
+        printError(`Invalid --estimate: "${estimateRaw}". Must be a number.`);
+        throw new CliExit(1);
+    }
+    const estimateUnit = stringFlag(flags, 'unit');
+    const targetDate = stringFlag(flags, 'target');
+    const created = await predictionsApi.recordPrediction(ctx, {
+        classTag,
+        claimText,
+        estimateValue,
+        estimateUnit,
+        targetDate,
+    });
+    console.log(`Prediction recorded: #${created.id} class=${created.classTag}`);
+    if (created.memoryId)
+        console.log(`  memory: ${created.memoryId}`);
+}
+//# sourceMappingURL=predictions.js.map