@polderlabs/bizar 10.0.7 → 10.2.0

package/cli/service-env.mjs

@@ -4,7 +4,7 @@
  * v5.x — Central env file builder for the Bizar service.
  *
  * Produces the content for `~/.config/bizar/service.env` (mode 0600),
- * which is sourced by the systemd/launchd service and the headroom companion.
+ * which is sourced by the systemd/launchd service.
  *
  * All BIZAR_* vars are written here so the service has a consistent view
  * of the environment. Values already present in `process.env` are honoured
@@ -31,7 +31,6 @@ export function defaultBizarEnv() {
     BIZAR_DASHBOARD_PORT: '4097',
     BIZAR_DASHBOARD_HOST: '127.0.0.1',
     BIZAR_LOG_LEVEL: 'info',
-    BIZAR_HEADROOM_AUTOSTART: '1',
     BIZAR_LIGHTRAG_AUTOSTART: '1',
     BIZAR_MEMORY_VAULT: join(home, '.bizar_memory'),
     CLINE_SERVER_PASSWORD: '',
@@ -77,11 +76,10 @@ function generatePassword() {
  * @param {object} opts
  * @param {string} [opts.bizarHome]   – default: ~/.config/bizar
  * @param {string} [opts.repoPath]    – absolute path to the repo root
- * @param {boolean} [opts.headroomAutoStart] – default: true
  * @param {boolean} [opts.lightragAutoStart] – default: true
  * @returns {string} env file content (does NOT write to disk)
  */
-export function buildServiceEnvFile({ bizarHome, repoPath, headroomAutoStart = true, lightragAutoStart = true } = {}) {
+export function buildServiceEnvFile({ bizarHome, repoPath, lightragAutoStart = true } = {}) {
   const home = homedir();
   const defaults = defaultBizarEnv();
 
@@ -91,11 +89,6 @@ export function buildServiceEnvFile({ bizarHome, repoPath, headroomAutoStart = t
     BIZAR_DASHBOARD_PORT:  process.env.BIZAR_DASHBOARD_PORT  || defaults.BIZAR_DASHBOARD_PORT,
     BIZAR_DASHBOARD_HOST:  process.env.BIZAR_DASHBOARD_HOST  || defaults.BIZAR_DASHBOARD_HOST,
     BIZAR_LOG_LEVEL:       process.env.BIZAR_LOG_LEVEL       || defaults.BIZAR_LOG_LEVEL,
-    BIZAR_HEADROOM_AUTOSTART: String(
-      process.env.BIZAR_HEADROOM_AUTOSTART !== undefined
-        ? (process.env.BIZAR_HEADROOM_AUTOSTART === '1' || process.env.BIZAR_HEADROOM_AUTOSTART === 'true' ? '1' : '0')
-        : (headroomAutoStart ? '1' : '0')
-    ),
     BIZAR_LIGHTRAG_AUTOSTART: String(
       process.env.BIZAR_LIGHTRAG_AUTOSTART !== undefined
         ? (process.env.BIZAR_LIGHTRAG_AUTOSTART === '1' || process.env.BIZAR_LIGHTRAG_AUTOSTART === 'true' ? '1' : '0')

package/cli/utils.mjs

@@ -121,13 +121,6 @@ export async function detectClaude() {
   return { exists, version, configDir: claudeConfigDir(), agentsDir: claudeAgentsDir() };
 }
 
-export async function detectHeadroom() {
-  return commandExists('headroom');
-}
-
-// Alias for backward-compat during migration
-export const detectRtk = detectHeadroom;
-
 export async function detectSemble() {
   if (commandExists('semble')) {
     return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polderlabs/bizar",
-  "version": "10.0.7",
+  "version": "10.2.0",
   "description": "Norse-pantheon multi-agent system for Claude Code — 14 agents across 4 cost tiers with cost-aware routing, plans, and a configurable agent harness. Ships as a single npm package with the dashboard server, Claude Code MCP server, and typed SDK.",
   "type": "module",
   "bin": {

package/packages/sdk/dist/agent/cron.d.ts

@@ -0,0 +1,44 @@
+/**
+ * src/agent/cron.ts
+ *
+ * Pillar A — Cron scheduled tasks.
+ *
+ * Exports:
+ *   addCronTask({ cron, prompt, recurring })
+ *   listCronTasks()
+ *   removeCronTask(id)
+ *
+ * Persists to `.bizar/cron.json`.
+ */
+export interface CronTask {
+    id: string;
+    cron: string;
+    prompt: string;
+    recurring: boolean;
+    createdAt: string;
+}
+/**
+ * Add a cron task.
+ *
+ * @param opts.cron       — cron expression (e.g. "0 * * * *")
+ * @param opts.prompt     — prompt to execute on trigger
+ * @param opts.recurring  — if false, task is removed after first run
+ * @param opts.repoRoot   — optional repo root override
+ * @returns the created CronTask
+ */
+export declare function addCronTask(opts: {
+    cron: string;
+    prompt: string;
+    recurring?: boolean;
+    repoRoot?: string;
+}): CronTask;
+/**
+ * List all cron tasks.
+ */
+export declare function listCronTasks(repoRoot?: string): CronTask[];
+/**
+ * Remove a cron task by id.
+ * @returns true if the task existed and was removed
+ */
+export declare function removeCronTask(id: string, repoRoot?: string): boolean;
+//# sourceMappingURL=cron.d.ts.map

package/packages/sdk/dist/agent/cron.js

@@ -0,0 +1,79 @@
+/**
+ * src/agent/cron.ts
+ *
+ * Pillar A — Cron scheduled tasks.
+ *
+ * Exports:
+ *   addCronTask({ cron, prompt, recurring })
+ *   listCronTasks()
+ *   removeCronTask(id)
+ *
+ * Persists to `.bizar/cron.json`.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+function cronStorePath(repoRoot) {
+    return join(repoRoot ?? process.cwd(), ".bizar", "cron.json");
+}
+function loadStore(repoRoot) {
+    const fp = cronStorePath(repoRoot);
+    if (!existsSync(fp))
+        return { tasks: [] };
+    try {
+        return JSON.parse(readFileSync(fp, "utf-8"));
+    }
+    catch {
+        return { tasks: [] };
+    }
+}
+function saveStore(store, repoRoot) {
+    const fp = cronStorePath(repoRoot);
+    const dir = join(fp, "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(fp, JSON.stringify(store, null, 2), "utf-8");
+}
+/**
+ * Add a cron task.
+ *
+ * @param opts.cron       — cron expression (e.g. "0 * * * *")
+ * @param opts.prompt     — prompt to execute on trigger
+ * @param opts.recurring  — if false, task is removed after first run
+ * @param opts.repoRoot   — optional repo root override
+ * @returns the created CronTask
+ */
+export function addCronTask(opts) {
+    const { cron, prompt, recurring = false, repoRoot } = opts;
+    const store = loadStore(repoRoot);
+    const task = {
+        id: randomUUID(),
+        cron,
+        prompt,
+        recurring,
+        createdAt: new Date().toISOString(),
+    };
+    store.tasks.push(task);
+    saveStore(store, repoRoot);
+    return task;
+}
+/**
+ * List all cron tasks.
+ */
+export function listCronTasks(repoRoot) {
+    return loadStore(repoRoot).tasks;
+}
+/**
+ * Remove a cron task by id.
+ * @returns true if the task existed and was removed
+ */
+export function removeCronTask(id, repoRoot) {
+    const store = loadStore(repoRoot);
+    const before = store.tasks.length;
+    store.tasks = store.tasks.filter((t) => t.id !== id);
+    if (store.tasks.length === before)
+        return false;
+    saveStore(store, repoRoot);
+    return true;
+}
+//# sourceMappingURL=cron.js.map

package/packages/sdk/dist/agent/heartbeat.d.ts

@@ -0,0 +1,43 @@
+/**
+ * src/agent/heartbeat.ts
+ *
+ * Pillar A — Heartbeat + session resume.
+ *
+ * Exports `startHeartbeat(intervalMs)` which returns a session ID and a
+ * JSONL writer that appends heartbeat records to
+ * `.harness/traces/heartbeat.jsonl`. Each record carries:
+ *   session_id, started_at, last_heartbeat_at, status
+ *
+ * Status transitions: running → idle → done | failed
+ */
+export type SessionStatus = "running" | "idle" | "failed" | "done";
+export interface HeartbeatRecord {
+    session_id: string;
+    started_at: string;
+    last_heartbeat_at: string;
+    status: SessionStatus;
+}
+/** Returns the path to the heartbeat log, resolved from repo root. */
+export declare function heartbeatPath(repoRoot: string): string;
+/**
+ * Start a heartbeat ticker.
+ *
+ * @param intervalMs  — milliseconds between heartbeat writes (default 30_000)
+ * @param repoRoot    — repository root (default process.cwd())
+ * @returns {{ sessionId: string, stop: () => void }}
+ */
+export declare function startHeartbeat(intervalMs?: number, repoRoot?: string): {
+    sessionId: string;
+    stop: () => void;
+};
+/**
+ * Mark a session as failed in the heartbeat log.
+ * Reads the original started_at from the JSONL file if available.
+ */
+export declare function failHeartbeat(sessionId: string, repoRoot?: string): void;
+/**
+ * Mark a session as done.
+ * Reads the original started_at from the JSONL file if available.
+ */
+export declare function stopHeartbeat(sessionId: string, repoRoot?: string): void;
+//# sourceMappingURL=heartbeat.d.ts.map

package/packages/sdk/dist/agent/heartbeat.js

@@ -0,0 +1,116 @@
+/**
+ * src/agent/heartbeat.ts
+ *
+ * Pillar A — Heartbeat + session resume.
+ *
+ * Exports `startHeartbeat(intervalMs)` which returns a session ID and a
+ * JSONL writer that appends heartbeat records to
+ * `.harness/traces/heartbeat.jsonl`. Each record carries:
+ *   session_id, started_at, last_heartbeat_at, status
+ *
+ * Status transitions: running → idle → done | failed
+ */
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+/** Returns the path to the heartbeat log, resolved from repo root. */
+export function heartbeatPath(repoRoot) {
+    return join(repoRoot, ".harness", "traces", "heartbeat.jsonl");
+}
+/**
+ * Start a heartbeat ticker.
+ *
+ * @param intervalMs  — milliseconds between heartbeat writes (default 30_000)
+ * @param repoRoot    — repository root (default process.cwd())
+ * @returns {{ sessionId: string, stop: () => void }}
+ */
+export function startHeartbeat(intervalMs = 30_000, repoRoot) {
+    const root = repoRoot ?? process.cwd();
+    const dir = join(root, ".harness", "traces");
+    const fp = heartbeatPath(root);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    const sessionId = randomUUID();
+    const startedAt = new Date().toISOString();
+    function writeRecord(status) {
+        const record = {
+            session_id: sessionId,
+            started_at: startedAt,
+            last_heartbeat_at: new Date().toISOString(),
+            status,
+        };
+        appendFileSync(fp, JSON.stringify(record) + "\n", "utf-8");
+    }
+    writeRecord("running");
+    const interval = setInterval(() => {
+        writeRecord("running");
+    }, intervalMs);
+    return {
+        sessionId,
+        stop: () => {
+            clearInterval(interval);
+            writeRecord("done");
+        },
+    };
+}
+/**
+ * Mark a session as failed in the heartbeat log.
+ * Reads the original started_at from the JSONL file if available.
+ */
+export function failHeartbeat(sessionId, repoRoot) {
+    const root = repoRoot ?? process.cwd();
+    const fp = heartbeatPath(root);
+    if (!existsSync(fp))
+        return;
+    const startedAt = _readStartedAt(fp, sessionId);
+    const record = {
+        session_id: sessionId,
+        started_at: startedAt,
+        last_heartbeat_at: new Date().toISOString(),
+        status: "failed",
+    };
+    appendFileSync(fp, JSON.stringify(record) + "\n", "utf-8");
+}
+/**
+ * Mark a session as done.
+ * Reads the original started_at from the JSONL file if available.
+ */
+export function stopHeartbeat(sessionId, repoRoot) {
+    const root = repoRoot ?? process.cwd();
+    const fp = heartbeatPath(root);
+    if (!existsSync(fp))
+        return;
+    const startedAt = _readStartedAt(fp, sessionId);
+    const record = {
+        session_id: sessionId,
+        started_at: startedAt,
+        last_heartbeat_at: new Date().toISOString(),
+        status: "done",
+    };
+    appendFileSync(fp, JSON.stringify(record) + "\n", "utf-8");
+}
+/** Find the original started_at for a session from the JSONL file. */
+function _readStartedAt(fp, sessionId) {
+    try {
+        const raw = readFileSync(fp, "utf-8");
+        for (const line of raw.split("\n").reverse()) {
+            if (!line)
+                continue;
+            try {
+                const rec = JSON.parse(line);
+                if (rec.session_id === sessionId && rec.started_at) {
+                    return rec.started_at;
+                }
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+    }
+    catch {
+        // ignore read errors
+    }
+    return new Date().toISOString();
+}
+//# sourceMappingURL=heartbeat.js.map

package/packages/sdk/dist/index.d.ts

@@ -21,5 +21,8 @@ export { SwarmTopologyRegistry, swarmTopologyRegistry, initSwarm, getSwarm, list
 export type { SwarmRecord, SwarmTopology, InitSwarmInput, InitSwarmResult, } from "./swarm-topology.js";
 export { ByzantineConsensus, type ByzantineConsensusOpts, QueenCoordinator, type QueenCoordinatorOpts, createConsensus, getSharedConsensus, resetSharedConsensus, type ConsensusHandle, type CreateConsensusOpts, PHASE_ORDER, DEFAULT_QUORUM, DEFAULT_PEER_COUNT, DEFAULT_MAX_FAULTS, } from "./consensus/index.js";
 export type { CommitResult, ConsensusOpts, ConsensusStatus, Decision, Phase, ProposeResult, Proposal, ProposalSnapshot, ProposalStatus, Vote, VoteResult, ViewChangeResult, } from "./consensus/types.js";
+export { recordInstinct, listInstincts, promoteInstinct, dropInstinct, recordDecision, listDecisions, verifyChain, datamark, } from "./learning/index.js";
+export { startHeartbeat, stopHeartbeat, failHeartbeat, heartbeatPath, type HeartbeatRecord, type SessionStatus, } from "./agent/heartbeat.js";
+export { addCronTask, listCronTasks, removeCronTask, type CronTask, } from "./agent/cron.js";
 export { SDK_VERSION } from "./version.js";
 //# sourceMappingURL=index.d.ts.map

package/packages/sdk/dist/index.js

@@ -21,5 +21,10 @@ export { BizarAgentRegistry, bizarAgentRegistry, } from "./agent-registry.js";
 export { SwarmTopologyRegistry, swarmTopologyRegistry, initSwarm, getSwarm, listSwarms, recordAgentInSwarm, decommissionSwarm, SWARM_TOPOLOGIES, DEFAULT_TOPOLOGY, DEFAULT_MAX_AGENTS, DEFAULT_SWARM_ID, } from "./swarm-topology.js";
 // F-039 — Byzantine fault-tolerant consensus (thin PBFT port).
 export { ByzantineConsensus, QueenCoordinator, createConsensus, getSharedConsensus, resetSharedConsensus, PHASE_ORDER, DEFAULT_QUORUM, DEFAULT_PEER_COUNT, DEFAULT_MAX_FAULTS, } from "./consensus/index.js";
+// F-034 — Self-learning (Pillar D): instincts + decisions logs.
+export { recordInstinct, listInstincts, promoteInstinct, dropInstinct, recordDecision, listDecisions, verifyChain, datamark, } from "./learning/index.js";
+// Pillar A — heartbeat + cron (autonomous long-running agents)
+export { startHeartbeat, stopHeartbeat, failHeartbeat, heartbeatPath, } from "./agent/heartbeat.js";
+export { addCronTask, listCronTasks, removeCronTask, } from "./agent/cron.js";
 export { SDK_VERSION } from "./version.js";
 //# sourceMappingURL=index.js.map

package/packages/sdk/dist/learning/decisions.d.ts

@@ -0,0 +1,46 @@
+/**
+ * learning/decisions.ts — Decisions log (append-only, tamper-evident).
+ *
+ * v10.1.1 — Pillar D: Decisions log backed by `.bizar/learning/decisions.jsonl`.
+ *
+ * Each entry:
+ *   {id, ts, event: 'decide'|'supersede'|'redact',
+ *    subject, rationale, refs?, prev_hash, hash}
+ *
+ * tamper-evident chain: sha256(prev_hash + entry_body) → current hash.
+ * Datamark on render: escape unicode surrogates via JSON.stringify replacer
+ * (same pattern as gstack's wrapUntrustedContent).
+ */
+interface DecisionInput {
+    event: "decide" | "supersede" | "redact";
+    subject: string;
+    rationale: string;
+    refs?: string[];
+    project?: string;
+}
+/** Record a new decision. Returns the created entry. */
+export declare function recordDecision({ event, subject, rationale, refs, project, }: DecisionInput): Record<string, unknown>;
+/** List all decisions. */
+export declare function listDecisions(opts?: {
+    project?: string;
+}): Record<string, unknown>[];
+/**
+ * Verify the tamper-evident chain.
+ * Returns { ok: true } if every entry's hash matches the computed hash
+ * and prev_hash chains correctly. Returns { ok: false, at: number } on
+ * the first break.
+ */
+export declare function verifyChain(opts?: {
+    project?: string;
+}): {
+    ok: boolean;
+    at?: number;
+};
+/**
+ * Datamark renderer — escape unicode surrogates so JSON.stringify never
+ * emits invalid strings when rendering decisions in the UI.
+ * Pattern borrowed from gstack's wrapUntrustedContent.
+ */
+export declare function datamark(value: unknown): unknown;
+export {};
+//# sourceMappingURL=decisions.d.ts.map

package/packages/sdk/dist/learning/decisions.js

@@ -0,0 +1,132 @@
+/**
+ * learning/decisions.ts — Decisions log (append-only, tamper-evident).
+ *
+ * v10.1.1 — Pillar D: Decisions log backed by `.bizar/learning/decisions.jsonl`.
+ *
+ * Each entry:
+ *   {id, ts, event: 'decide'|'supersede'|'redact',
+ *    subject, rationale, refs?, prev_hash, hash}
+ *
+ * tamper-evident chain: sha256(prev_hash + entry_body) → current hash.
+ * Datamark on render: escape unicode surrogates via JSON.stringify replacer
+ * (same pattern as gstack's wrapUntrustedContent).
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+const LEARNING_DIR = ".bizar/learning";
+const DECISIONS_FILE = "decisions.jsonl";
+function decisionsPath(project) {
+    const root = project && project !== "." ? project : process.cwd();
+    return join(root, LEARNING_DIR, DECISIONS_FILE);
+}
+function ensureDir(project) {
+    const dir = join(decisionsPath(project), "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+/** SHA256 hash of a string, truncated to 16 hex chars. */
+function sha16(s) {
+    return createHash("sha256").update(s, "utf8").digest("hex").slice(0, 16);
+}
+/** Build a content-addressable id from event + subject + ts. */
+function makeId(ts, subject, event) {
+    return sha16(`${ts}:${subject}:${event}`);
+}
+/** Compute the hash for an entry (excludes the hash field itself). */
+function entryHash(entry) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { hash: _h, ...body } = entry;
+    return sha16(JSON.stringify(body));
+}
+/** Record a new decision. Returns the created entry. */
+export function recordDecision({ event, subject, rationale, refs = [], project, }) {
+    ensureDir(project);
+    const path = decisionsPath(project);
+    // Read previous entry to get prev_hash.
+    let prevHash = "0000000000000000";
+    if (existsSync(path)) {
+        try {
+            const raw = readFileSync(path, "utf8");
+            const lines = raw.split("\n").filter((l) => l.trim());
+            if (lines.length > 0) {
+                const last = JSON.parse(lines[lines.length - 1]);
+                prevHash = String(last.hash ?? prevHash);
+            }
+        }
+        catch { /* best-effort: start from genesis */ }
+    }
+    const ts = Date.now();
+    const id = makeId(ts, subject, event);
+    const refsArr = Array.isArray(refs) ? refs : [];
+    const entry = {
+        id,
+        ts,
+        event,
+        subject: String(subject),
+        rationale: String(rationale),
+        refs: refsArr.map(String),
+        prev_hash: prevHash,
+    };
+    entry.hash = sha16(JSON.stringify({ ...entry }));
+    appendFileSync(path, JSON.stringify(entry) + "\n", "utf8");
+    return entry;
+}
+/** List all decisions. */
+export function listDecisions(opts = {}) {
+    const path = decisionsPath(opts.project);
+    if (!existsSync(path))
+        return [];
+    try {
+        const raw = readFileSync(path, "utf8");
+        return raw
+            .split("\n")
+            .filter((l) => l.trim())
+            .map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => e !== null);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Verify the tamper-evident chain.
+ * Returns { ok: true } if every entry's hash matches the computed hash
+ * and prev_hash chains correctly. Returns { ok: false, at: number } on
+ * the first break.
+ */
+export function verifyChain(opts = {}) {
+    const decisions = listDecisions(opts);
+    if (decisions.length === 0)
+        return { ok: true };
+    let prevHash = "0000000000000000";
+    for (let i = 0; i < decisions.length; i++) {
+        const e = decisions[i];
+        if (String(e.prev_hash) !== prevHash)
+            return { ok: false, at: i };
+        const computed = entryHash(e);
+        if (String(e.hash) !== computed)
+            return { ok: false, at: i };
+        prevHash = String(e.hash);
+    }
+    return { ok: true };
+}
+/**
+ * Datamark renderer — escape unicode surrogates so JSON.stringify never
+ * emits invalid strings when rendering decisions in the UI.
+ * Pattern borrowed from gstack's wrapUntrustedContent.
+ */
+export function datamark(value) {
+    if (typeof value !== "string")
+        return value;
+    // Replace isolated surrogates with U+FFFD REPLACEMENT CHARACTER.
+    return value.replace(/[\uD800-\uDFFF]/g, (c) => c.charCodeAt(0) >= 0xD800 ? "�" : c);
+}
+//# sourceMappingURL=decisions.js.map

package/packages/sdk/dist/learning/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * learning/index.ts — Public re-exports for the self-learning module.
+ *
+ * v10.1.1 — Pillar D.
+ */
+export { recordInstinct, listInstincts, promoteInstinct, dropInstinct, } from "./instincts.js";
+export { recordDecision, listDecisions, verifyChain, datamark, } from "./decisions.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/sdk/dist/learning/index.js

@@ -0,0 +1,8 @@
+/**
+ * learning/index.ts — Public re-exports for the self-learning module.
+ *
+ * v10.1.1 — Pillar D.
+ */
+export { recordInstinct, listInstincts, promoteInstinct, dropInstinct, } from "./instincts.js";
+export { recordDecision, listDecisions, verifyChain, datamark, } from "./decisions.js";
+//# sourceMappingURL=index.js.map

package/packages/sdk/dist/learning/instincts.d.ts

@@ -0,0 +1,38 @@
+/**
+ * learning/instincts.ts — Instinct log for Bizar self-learning.
+ *
+ * v10.1.1 — Pillar D: Instinct log backed by `.bizar/learning/instincts.jsonl`.
+ *
+ * Each entry:
+ *   {id, trigger, action, confidence: 0-1, evidence: string[],
+ *    scope: 'project'|'global', project, created_at, updated_at}
+ *
+ * Atomic append via fs.appendFileSync (Node's async form flushes by default;
+ * verified by the smoke test in instincts.test.mjs).
+ *
+ * Auto-write path: PostToolUse hook on Bash for high-frequency commands
+ * (npm install, git push, etc.) via `.claude/hooks/auto-instinct.sh`.
+ */
+/** Record a new instinct. Returns the created entry. */
+export declare function recordInstinct({ trigger, action, confidence, evidence, scope, project, }: {
+    trigger: string;
+    action: string;
+    confidence?: number;
+    evidence?: string[];
+    scope?: "project" | "global";
+    project?: string;
+}): Record<string, unknown>;
+/** List all instincts, optionally filtered by scope. */
+export declare function listInstincts(opts?: {
+    scope?: "project" | "global";
+    project?: string;
+}): Record<string, unknown>[];
+/** Promote an instinct's confidence (returns updated entry or null). */
+export declare function promoteInstinct(id: string, newConfidence: number, opts?: {
+    project?: string;
+}): Record<string, unknown> | null;
+/** Drop an instinct by id (returns true if found and removed). */
+export declare function dropInstinct(id: string, opts?: {
+    project?: string;
+}): boolean;
+//# sourceMappingURL=instincts.d.ts.map