Local-first 🧠memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.
TypeScript
/**
* `o2b brain` subcommand dispatcher.
*
* Routes Brain verbs to thin wrappers over `src/core/brain/*`.
* Each verb handler lives in `./verbs/<name>.ts`; this file only
* dispatches and prints help.
*/
import { CliError } from "./argparse.ts";
import { BRAIN_HELP, VERB_HELP } from "./brain/helpers.ts";
import {
cmdBrainInit,
cmdBrainFeedback,
cmdBrainNote,
cmdBrainLifecycle,
cmdBrainNoteLifecycle,
cmdBrainScaffoldStub,
cmdBrainClaims,
cmdBrainDecision,
cmdBrainTension,
cmdBrainDream,
cmdBrainApplyEvidence,
cmdBrainLessons,
cmdBrainDigest,
cmdBrainIntentReview,
cmdBrainRetention,
cmdBrainMonthly,
cmdBrainQuery,
cmdBrainAgentQuery,
cmdBrainAgentDiff,
cmdBrainWrites,
cmdBrainReject,
cmdBrainFreeze,
cmdBrainPin,
cmdBrainUnfreeze,
handleBrainLogSubcommand,
cmdBrainAttest,
cmdBrainUnpin,
cmdBrainState,
cmdBrainSetPrimary,
cmdBrainProtect,
cmdBrainUnprotect,
cmdBrainRollback,
cmdBrainDoctor,
cmdBrainHygiene,
cmdBrainRefresh,
cmdBrainAnticipate,
cmdBrainWatchdog,
cmdBrainHealth,
cmdBrainHealthBaseline,
cmdBrainStatus,
cmdBrainHistory,
cmdBrainActivation,
cmdBrainTruth,
cmdBrainFacts,
cmdBrainDeadEnd,
cmdBrainForesight,
cmdBrainLabel,
cmdBrainBridges,
cmdBrainClusters,
cmdBrainVitals,
cmdBrainCoOccurrence,
cmdBrainHallways,
cmdBrainFileContext,
cmdBrainBenchmark,
cmdBrainTune,
cmdBrainAttr,
cmdBrainTiers,
cmdBrainSecret,
cmdBrainMaintenance,
cmdBrainAudit,
cmdBrainMorningBrief,
cmdBrainCodec,
cmdBrainSources,
cmdBrainSchema,
cmdBrainSettings,
cmdBrainGraphExport,
cmdBrainGraphImport,
cmdBrainBankExport,
cmdBrainBankImport,
cmdBrainBacklinks,
cmdBrainSemanticsBackfill,
cmdBrainAuthoredAtBackfill,
cmdBrainPrivacyMarkerRestamp,
cmdBrainMcpLandscape,
cmdBrainMerge,
cmdBrainExplorer,
cmdBrainExport,
cmdBrainOkfExport,
cmdBrainOkfImport,
cmdBrainKnowledgePack,
cmdBrainUpgrade,
handleBrainSnapshotSubcommand,
cmdBrainScanInline,
cmdBrainScanCitations,
cmdBrainEntity,
cmdBrainImportSession,
cmdBrainForgetSource,
cmdBrainBatchPlan,
cmdBrainPreExtract,
runBrainExtract,
cmdBrainDistill,
cmdBrainHandoff,
cmdBrainIntention,
cmdBrainProject,
cmdBrainSource,
cmdBrainLinks,
cmdBrainProfile,
cmdBrainSgrep,
cmdBrainContinuity,
cmdBrainPayload,
cmdBrainReceipts,
cmdBrainStorage,
cmdBrainChanges,
cmdBrainMigrateStore,
cmdBrainSessionSummary,
cmdBrainIdeaLineage,
cmdBrainNoteHistory,
cmdBrainBench,
cmdBrainGit,
cmdBrainArchitect,
cmdBrainSession,
cmdBrainPanel,
cmdBrainTrigger,
cmdBrainDeepSynthesis,
cmdBrainDiarize,
cmdBrainExtractSignals,
cmdBrainDeadLetters,
cmdBrainDesignNote,
cmdBrainIdeas,
cmdBrainSessionHook,
cmdBrainImportClaudeMemory,
cmdBrainPageDedup,
cmdBrainTokenFootprint,
cmdBrainContextPack,
cmdBrainContextReceipts,
cmdBrainEventTrace,
cmdBrainContextPresets,
cmdBrainPreCompactExtract,
cmdBrainPostCompactAudit,
cmdBrainRecallTelemetry,
cmdBrainKnowledgeGaps,
cmdBrainGenerationReports,
cmdBrainSkillProposals,
cmdBrainProceduralMemory,
cmdBrainProceduralGraph,
cmdBrainRecurrence,
cmdBrainObligation,
cmdBrainAgenda,
cmdBrainToday,
cmdBrainApplyMarkers,
cmdBrainPending,
cmdBrainCapture,
cmdBrainExpire,
cmdBrainTelegramCapture,
cmdBrainInboxDrain,
cmdBrainRepairLane,
cmdBrainOrphanRepair,
cmdBrainSignal,
cmdBrainAttentionFlows,
cmdBrainSessionDescribe,
cmdBrainSessionExpand,
cmdBrainSessionGrep,
cmdBrainLint,
cmdBrainValidate,
cmdBrainActions,
cmdBrainSummary,
cmdBrainUnlinked,
cmdBrainSynthesise,
cmdBrainMocAudit,
cmdBrainTimeline,
cmdBrainEvolution,
cmdBrainStale,
cmdBrainDaily,
cmdBrainWeekly,
cmdBrainPermissions,
} from "./brain/verbs/index.ts";
/**
* Brain verbs whose whole purpose is replaying records authored
* somewhere else, spelled as the verb path the caller types. The CLI
* entry point reads this to claim the `import` origin channel for the
* process (`src/core/origin-channel.ts`) instead of the `cli` every
* other verb gets.
*
* It lives here, beside the `switch` that dispatches these verbs, so a
* renamed verb moves both in one edit; a copy of the list in `main.ts`
* would be a copy that goes stale the first time one is renamed.
*
* Membership is "replays records this operator did not author now",
* which is why `scan-inline` is absent: it captures `@osb` markers the
* operator wrote in their own vault during this session, and that is a
* `cli` capture wearing an unusual input format.
*/
export const BRAIN_IMPORT_VERB_PATHS: ReadonlyArray<string> = Object.freeze([
"bank-import",
"git ingest",
"graph-import",
"import-claude-memory",
"import-session",
"knowledge-pack install",
]);
/**
* Whether `o2b brain <argv…>` names one of {@link BRAIN_IMPORT_VERB_PATHS}.
* Matches on the first two words so a nested verb (`git ingest`) is
* distinguishable from its read-only siblings (`git status`, `git find`).
*/
export function isBrainImportVerb(argv: ReadonlyArray<string>): boolean {
if (argv.length === 0) return false;
const one = argv[0]!;
const two = argv.length > 1 ? `${one} ${argv[1]!}` : one;
return BRAIN_IMPORT_VERB_PATHS.includes(one) || BRAIN_IMPORT_VERB_PATHS.includes(two);
}
export async function handleBrainSubcommand(argv: ReadonlyArray<string>): Promise<number> {
if (argv.length === 0 || argv[0] === "-h" || argv[0] === "--help") {
process.stdout.write(BRAIN_HELP);
return argv.length === 0 ? 2 : 0;
}
const verb = argv[0]!;
const rest = argv.slice(1);
if (rest.length === 1 && (rest[0] === "-h" || rest[0] === "--help")) {
const text = VERB_HELP[verb];
if (text) {
process.stdout.write(text);
return 0;
}
process.stdout.write(BRAIN_HELP);
return 2;
}
try {
switch (verb) {
case "init":
return await cmdBrainInit(rest);
case "feedback":
return await cmdBrainFeedback(rest);
case "note":
return await cmdBrainNote(rest);
case "lifecycle":
return await cmdBrainLifecycle(rest);
case "expire":
return await cmdBrainExpire(rest);
case "note-lifecycle":
return await cmdBrainNoteLifecycle(rest);
case "scaffold-stub":
return await cmdBrainScaffoldStub(rest);
case "claims":
return await cmdBrainClaims(rest);
case "decision":
return await cmdBrainDecision(rest);
case "tension":
return await cmdBrainTension(rest);
case "dream":
return await cmdBrainDream(rest);
case "apply-evidence":
return await cmdBrainApplyEvidence(rest);
case "digest":
return await cmdBrainDigest(rest);
case "intent-review":
return await cmdBrainIntentReview(rest);
case "retention":
return await cmdBrainRetention(rest);
case "monthly":
return await cmdBrainMonthly(rest);
case "query":
return await cmdBrainQuery(rest);
case "agent-query":
return await cmdBrainAgentQuery(rest);
case "agent-diff":
return await cmdBrainAgentDiff(rest);
case "writes":
return await cmdBrainWrites(rest);
case "reject":
return await cmdBrainReject(rest);
case "freeze":
return await cmdBrainFreeze(rest);
case "unfreeze":
return await cmdBrainUnfreeze(rest);
case "log":
return await handleBrainLogSubcommand(rest);
case "attest":
return await cmdBrainAttest(rest);
case "pin":
return await cmdBrainPin(rest);
case "unpin":
return await cmdBrainUnpin(rest);
case "lessons":
return await cmdBrainLessons(rest);
case "state":
return await cmdBrainState(rest);
case "set-primary":
return await cmdBrainSetPrimary(rest);
case "protect":
return await cmdBrainProtect(rest);
case "unprotect":
return await cmdBrainUnprotect(rest);
case "snapshot":
return await handleBrainSnapshotSubcommand(rest);
case "rollback":
return await cmdBrainRollback(rest);
case "doctor":
return await cmdBrainDoctor(rest);
case "hygiene":
return await cmdBrainHygiene(rest);
case "refresh":
return await cmdBrainRefresh(rest);
case "anticipate":
return await cmdBrainAnticipate(rest);
case "watchdog":
return await cmdBrainWatchdog(rest);
case "health":
return await cmdBrainHealth(rest);
case "health-baseline":
return await cmdBrainHealthBaseline(rest);
case "status":
return await cmdBrainStatus(rest);
case "history":
return await cmdBrainHistory(rest);
case "activation":
return await cmdBrainActivation(rest);
case "truth":
return await cmdBrainTruth(rest);
case "facts":
return await cmdBrainFacts(rest);
case "dead-end":
return await cmdBrainDeadEnd(rest);
case "foresight":
return await cmdBrainForesight(rest);
case "label":
return await cmdBrainLabel(rest);
case "bridges":
return await cmdBrainBridges(rest);
case "clusters":
return await cmdBrainClusters(rest);
case "vitals":
return await cmdBrainVitals(rest);
case "co-occurrence":
return await cmdBrainCoOccurrence(rest);
case "hallways":
return await cmdBrainHallways(rest);
case "file-context":
return await cmdBrainFileContext(rest);
case "benchmark":
return await cmdBrainBenchmark(rest);
case "tune":
return await cmdBrainTune(rest);
case "attr":
return await cmdBrainAttr(rest);
case "tiers":
return await cmdBrainTiers(rest);
case "secret":
return await cmdBrainSecret(rest);
case "maintenance":
return await cmdBrainMaintenance(rest);
case "audit":
return await cmdBrainAudit(rest);
case "morning-brief":
return await cmdBrainMorningBrief(rest);
case "codec":
return await cmdBrainCodec(rest);
case "sources":
return await cmdBrainSources(rest);
case "schema":
return await cmdBrainSchema(rest);
case "settings":
return await cmdBrainSettings(rest);
case "graph-export":
return await cmdBrainGraphExport(rest);
case "graph-import":
return await cmdBrainGraphImport(rest);
case "bank-export":
return await cmdBrainBankExport(rest);
case "bank-import":
return await cmdBrainBankImport(rest);
case "backlinks":
return await cmdBrainBacklinks(rest);
case "semantics-backfill":
return await cmdBrainSemanticsBackfill(rest);
case "authored-at-backfill":
return await cmdBrainAuthoredAtBackfill(rest);
case "privacy-marker-restamp":
return await cmdBrainPrivacyMarkerRestamp(rest);
case "mcp-landscape":
return await cmdBrainMcpLandscape(rest);
case "scan-inline":
return await cmdBrainScanInline(rest);
case "scan-citations":
return cmdBrainScanCitations(rest);
case "import-session":
return await cmdBrainImportSession(rest);
case "handoff":
return await cmdBrainHandoff(rest);
case "intention":
return await cmdBrainIntention(rest);
case "project":
return await cmdBrainProject(rest);
case "source":
return await cmdBrainSource(rest);
case "forget-source":
return await cmdBrainForgetSource(rest);
case "batch-plan":
return await cmdBrainBatchPlan(rest);
case "pre-extract":
return await cmdBrainPreExtract(rest);
case "extract":
return await runBrainExtract(rest);
case "distill":
return await cmdBrainDistill(rest);
case "links":
return await cmdBrainLinks(rest);
case "profile":
return await cmdBrainProfile(rest);
case "sgrep":
return await cmdBrainSgrep(rest);
case "continuity":
return await cmdBrainContinuity(rest);
case "payload":
return await cmdBrainPayload(rest);
case "receipts":
return await cmdBrainReceipts(rest);
case "storage":
return await cmdBrainStorage(rest);
case "changes":
return await cmdBrainChanges(rest);
case "migrate-store":
return await cmdBrainMigrateStore(rest);
case "session-summary":
return await cmdBrainSessionSummary(rest);
case "idea-lineage":
return await cmdBrainIdeaLineage(rest);
case "note-history":
return await cmdBrainNoteHistory(rest);
case "bench":
return await cmdBrainBench(rest);
case "git":
return await cmdBrainGit(rest);
case "architect":
return await cmdBrainArchitect(rest);
case "session":
return await cmdBrainSession(rest);
case "panel":
return await cmdBrainPanel(rest);
case "trigger":
return await cmdBrainTrigger(rest);
case "deep-synthesis":
return await cmdBrainDeepSynthesis(rest);
case "diarize":
return await cmdBrainDiarize(rest);
case "extract-signals":
return await cmdBrainExtractSignals(rest);
case "dead-letters":
return await cmdBrainDeadLetters(rest);
case "design-note":
return await cmdBrainDesignNote(rest);
case "ideas":
return await cmdBrainIdeas(rest);
case "entity":
return await cmdBrainEntity(rest);
case "session-hook":
return await cmdBrainSessionHook(rest);
case "import-claude-memory":
return await cmdBrainImportClaudeMemory(rest);
case "merge":
return await cmdBrainMerge(rest);
case "upgrade":
return await cmdBrainUpgrade(rest);
case "export":
return await cmdBrainExport(rest);
case "okf-export":
return await cmdBrainOkfExport(rest);
case "okf-import":
return await cmdBrainOkfImport(rest);
case "knowledge-pack":
return await cmdBrainKnowledgePack(rest);
case "explorer":
return await cmdBrainExplorer(rest);
case "page-dedup":
return await cmdBrainPageDedup(rest);
case "token-footprint":
return await cmdBrainTokenFootprint(rest);
case "context-pack":
return await cmdBrainContextPack(rest);
case "context-receipts":
return await cmdBrainContextReceipts(rest);
case "event-trace":
return await cmdBrainEventTrace(rest);
case "context-presets":
return await cmdBrainContextPresets(rest);
case "pre-compact-extract":
return await cmdBrainPreCompactExtract(rest);
case "post-compact-audit":
return await cmdBrainPostCompactAudit(rest);
case "recall-telemetry":
return await cmdBrainRecallTelemetry(rest);
case "knowledge-gaps":
return await cmdBrainKnowledgeGaps(rest);
case "generation-reports":
return await cmdBrainGenerationReports(rest);
case "skill-proposals":
return await cmdBrainSkillProposals(rest);
case "procedural-memory":
return await cmdBrainProceduralMemory(rest);
case "procedural-graph":
return await cmdBrainProceduralGraph(rest);
case "recurrence":
return await cmdBrainRecurrence(rest);
case "attention-flows":
return await cmdBrainAttentionFlows(rest);
case "obligation":
return await cmdBrainObligation(rest);
case "agenda":
return await cmdBrainAgenda(rest);
case "today":
return await cmdBrainToday(rest);
case "apply-markers":
return await cmdBrainApplyMarkers(rest);
case "pending":
return await cmdBrainPending(rest);
case "signal":
return await cmdBrainSignal(rest);
case "capture":
return await cmdBrainCapture(rest);
case "telegram-capture":
return await cmdBrainTelegramCapture(rest);
case "inbox-drain":
return await cmdBrainInboxDrain(rest);
case "repair-lane":
return await cmdBrainRepairLane(rest);
case "orphan-repair":
return await cmdBrainOrphanRepair(rest);
case "session-grep":
return await cmdBrainSessionGrep(rest);
case "session-describe":
return await cmdBrainSessionDescribe(rest);
case "session-expand":
return await cmdBrainSessionExpand(rest);
case "lint":
return await cmdBrainLint(rest);
case "validate":
return await cmdBrainValidate(rest);
case "actions":
return await cmdBrainActions(rest);
case "summary":
return await cmdBrainSummary(rest);
case "unlinked":
return await cmdBrainUnlinked(rest);
case "synthesise":
return await cmdBrainSynthesise(rest);
case "moc-audit":
return await cmdBrainMocAudit(rest);
case "timeline":
return await cmdBrainTimeline(rest);
case "evolution":
return await cmdBrainEvolution(rest);
case "stale":
return await cmdBrainStale(rest);
case "daily":
return await cmdBrainDaily(rest);
case "weekly":
return await cmdBrainWeekly(rest);
case "permissions":
return await cmdBrainPermissions(rest);
default:
process.stderr.write(`error: unknown brain verb: ${verb}\n`);
process.stdout.write(BRAIN_HELP);
return 2;
}
} catch (exc) {
if (exc instanceof CliError) {
process.stderr.write(`error: ${exc.message}\n`);
return 1;
}
throw exc;
}
}