@oortmem/claude-code 0.0.0-stage → 0.1.1

package/dist/hooks.js

@@ -0,0 +1,321 @@
+import * as fs from 'node:fs';
+import { z } from 'zod';
+import { activation, formatForInjection, localGrant, localScope, resolveProjectId, recall, shouldRecall, } from '@oortmem/core';
+import { drainQueue, enqueueObservations, hasPendingQueue } from './queue.js';
+import { parseTranscriptDetailed, selectAfterCursor } from './transcript.js';
+/** Full recall gets this long before the hook falls back to lexical-only recall (CON-57: was 2.5 s). */
+export const RECALL_TIMEOUT_MS = 1500;
+/** At most this many observations are queued per Stop (the newest). */
+export const STOP_MAX_OBSERVATIONS = 20;
+/** Claude Code moves a longer `additionalContext` to a file and injects only a preview. */
+const CONTEXT_MAX_CHARS = 10_000;
+const EMPTY = { stdout: '', exitCode: 0 };
+const TIMEOUT = Symbol('timeout');
+export const cursorKey = (session) => `claude-code:${session}`;
+function scopeFor(cwd, deps) {
+    return deps.scope ?? localScope(resolveProjectId(cwd, deps.config.home));
+}
+/** The scope's project plus global memories. A private project's memories carry its own id. */
+export function filterFor(scope) {
+    return {
+        orgId: scope.orgId,
+        customerId: scope.customerId,
+        agentId: scope.agentId,
+        projectIds: [...new Set([scope.projectId ?? null, null])],
+    };
+}
+/** The grant for `filterFor(scope)`: what hooks, import and the CLI read and write. */
+export function grantFor(scope) {
+    return localGrant(filterFor(scope));
+}
+function contextOutput(event, text) {
+    if (text.length === 0)
+        return EMPTY;
+    return {
+        stdout: JSON.stringify({
+            hookSpecificOutput: { hookEventName: event, additionalContext: text },
+        }),
+        exitCode: 0,
+    };
+}
+function withTimeout(p, ms) {
+    let timer;
+    const t = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(TIMEOUT), ms);
+    });
+    return Promise.race([p, t]).finally(() => clearTimeout(timer));
+}
+/** Runs `body` with a log entry it fills in; the entry is written once, whatever happens. */
+async function logged(base, deps, body) {
+    const t0 = performance.now();
+    const entry = { ...base, project: null, outcome: 'error', counts: {}, timings: {} };
+    try {
+        return await body(entry);
+    }
+    catch {
+        entry.outcome = 'error';
+        return EMPTY;
+    }
+    finally {
+        entry.timings['totalMs'] = performance.now() - t0;
+        deps.log.write(entry);
+    }
+}
+export async function handleUserPromptSubmit(input, deps) {
+    return logged({ event: 'UserPromptSubmit', session: input.session_id }, deps, async (entry) => {
+        const gate = shouldRecall(input.prompt);
+        if (!gate.recall) {
+            entry.outcome = `skipped:${gate.reason}`;
+            return EMPTY;
+        }
+        const scope = scopeFor(input.cwd, deps);
+        entry.project = scope.projectId ?? null;
+        const q = { text: input.prompt, scope: filterFor(scope) };
+        const now = deps.now?.() ?? new Date();
+        const { store, config } = deps;
+        const degraded = [];
+        const t = performance.now();
+        let result;
+        if (deps.remote !== undefined) {
+            // Oort Cloud: the cloud recalls. A timeout or an error injects nothing, never a local guess.
+            const remote = deps.remote.recall({
+                text: input.prompt,
+                ...(scope.projectId !== undefined && { projectId: scope.projectId }),
+            });
+            remote.catch(() => { });
+            let r;
+            try {
+                r = await withTimeout(remote, RECALL_TIMEOUT_MS);
+            }
+            catch {
+                r = undefined;
+            }
+            entry.timings['recallMs'] = performance.now() - t;
+            if (r === TIMEOUT || r === undefined) {
+                entry.degraded = [r === TIMEOUT ? 'cloud-timeout' : 'cloud-error'];
+                entry.counts = { memories: 0, chars: 0 };
+                entry.outcome = 'empty';
+                return EMPTY;
+            }
+            result = r;
+        }
+        else {
+            const full = recall(q, {
+                store,
+                config,
+                now,
+                ...(deps.embed !== undefined && { embed: deps.embed }),
+                ...(deps.rerank !== undefined && { rerank: deps.rerank }),
+            });
+            // The full recall may lose the race and fail later; nobody awaits it then.
+            full.catch(() => { });
+            try {
+                const r = await withTimeout(full, RECALL_TIMEOUT_MS);
+                if (r === TIMEOUT) {
+                    degraded.push('timeout');
+                    result = await recall(q, { store, config, now });
+                }
+                else {
+                    result = r;
+                }
+            }
+            catch {
+                degraded.push('error');
+                result = await recall(q, { store, config, now });
+            }
+            entry.timings['recallMs'] = performance.now() - t;
+        }
+        // Per-stage timings from recall (numbers only), so slow stages show in the log (CON-57).
+        for (const [k, ms] of Object.entries(result.timings)) {
+            if (k !== 'totalMs' && k !== 'gateMs')
+                entry.timings[k] = ms;
+        }
+        degraded.push(...(result.degraded ?? []));
+        entry.degraded = [...new Set(degraded)];
+        const text = formatForInjection(result, Math.min(config.recall.budgetChars, CONTEXT_MAX_CHARS), now);
+        entry.counts = {
+            memories: result.memories.length,
+            chars: text.length,
+            ...(result.abstained === true && { abstained: 1 }),
+            ...(result.gate !== undefined && { gateDropped: result.gate.dropped }),
+            ...(result.rerankSkipped !== undefined && { rerankSkipped: 1 }),
+            ...(result.embedSkipped !== undefined && { embedSkipped: 1 }),
+        };
+        // Abstained: candidates were found but none was relevant enough, so nothing is injected.
+        entry.outcome =
+            text.length > 0 ? 'injected' : result.abstained === true ? 'abstained' : 'empty';
+        return contextOutput('UserPromptSubmit', text);
+    });
+}
+export async function handleStop(input, deps) {
+    return logged({ event: 'Stop', session: input.session_id }, deps, async (entry) => {
+        // Claude is already continuing because of a stop hook; this turn is not over.
+        if (input.stop_hook_active) {
+            entry.outcome = 'skipped:stop-hook-active';
+            return EMPTY;
+        }
+        const scope = scopeFor(input.cwd, deps);
+        entry.project = scope.projectId ?? null;
+        let text;
+        try {
+            text = fs.readFileSync(input.transcript_path, 'utf8');
+        }
+        catch {
+            entry.outcome = 'no-transcript';
+            return EMPTY;
+        }
+        const t = performance.now();
+        const detailed = parseTranscriptDetailed(text);
+        entry.timings['parseMs'] = performance.now() - t;
+        const key = cursorKey(input.session_id);
+        const grant = grantFor(scope);
+        const sel = selectAfterCursor(detailed, await deps.store.getCursor(grant, key));
+        let fresh = sel.fresh;
+        entry.counts = { turns: detailed.length, observations: fresh.length };
+        // Compaction or rotation dropped the cursor's row; take only the newest turns.
+        if (!sel.cursorFound)
+            entry.counts['cursorMissing'] = 1;
+        if (fresh.length > STOP_MAX_OBSERVATIONS) {
+            entry.counts['capped'] = fresh.length - STOP_MAX_OBSERVATIONS;
+            fresh = fresh.slice(-STOP_MAX_OBSERVATIONS);
+        }
+        const now = deps.now?.() ?? new Date();
+        const { queued, dropped } = enqueueObservations(deps.config.home, input.session_id, scope, fresh, now);
+        entry.counts['queued'] = queued;
+        entry.counts['dropped'] = dropped;
+        const last = fresh.at(-1)?.turnRef;
+        if (last !== undefined)
+            await deps.store.setCursor(grant, key, last);
+        if (queued > 0 || hasPendingQueue(deps.config.home)) {
+            try {
+                deps.spawnDrain?.();
+            }
+            catch {
+                entry.counts['spawnFailed'] = 1;
+            }
+        }
+        entry.outcome = queued > 0 ? 'queued' : 'nothing-new';
+        return EMPTY;
+    });
+}
+export async function handleSessionStart(input, deps) {
+    return logged({ event: 'SessionStart', session: input.session_id }, deps, async (entry) => {
+        const scope = scopeFor(input.cwd, deps);
+        entry.project = scope.projectId ?? null;
+        const now = deps.now?.() ?? new Date();
+        const { config } = deps;
+        let current;
+        if (deps.remote !== undefined) {
+            try {
+                current = await deps.remote.sessionMemories(scope.projectId !== undefined ? { projectId: scope.projectId } : {});
+            }
+            catch {
+                entry.degraded = ['cloud-error'];
+                entry.counts = { memories: 0, chars: 0 };
+                entry.outcome = 'empty';
+                return EMPTY;
+            }
+        }
+        else {
+            current = await deps.store.list(grantFor(scope));
+        }
+        const picked = current
+            .filter((m) => m.pinned || m.tier === 'hot')
+            .map((m) => ({
+            ...m,
+            explanation: {
+                fused: 0,
+                rrf: 0,
+                coverage: 0,
+                activation: activation(m.accessLog, m.salience, now, config.activation),
+                hydrated: false,
+            },
+        }))
+            .sort((a, b) => Number(b.pinned) - Number(a.pinned) ||
+            b.explanation.activation - a.explanation.activation);
+        const budget = Math.floor(Math.min(config.recall.budgetChars, CONTEXT_MAX_CHARS) / 2);
+        const text = formatForInjection({ memories: picked, timings: {} }, budget, now);
+        entry.counts = { memories: picked.length, chars: text.length };
+        entry.outcome = text.length > 0 ? 'injected' : 'empty';
+        return contextOutput('SessionStart', text);
+    });
+}
+const UserPromptSubmitInput = z.looseObject({
+    session_id: z.string(),
+    cwd: z.string(),
+    prompt: z.string(),
+});
+const StopInput = z.looseObject({
+    session_id: z.string(),
+    cwd: z.string(),
+    transcript_path: z.string(),
+    stop_hook_active: z.boolean().default(false),
+});
+const SessionStartInput = z.looseObject({
+    session_id: z.string(),
+    cwd: z.string(),
+    source: z.string().optional(),
+});
+/**
+ * The `oort hook <event>` entry point: parses the hook's stdin JSON (unknown
+ * fields are kept and ignored) and dispatches. `drain` ignores stdin. Invalid
+ * input logs one line and yields empty stdout; nothing here ever throws.
+ *
+ * Task 13 (CLI): write `stdout`, then call `process.exit(0)` at once; after a
+ * recall timeout the losing full recall is still pending and would hold the process.
+ */
+export async function runHook(event, stdinText, deps) {
+    let session = null;
+    try {
+        if (event === 'drain') {
+            await drainQueue(deps);
+            return EMPTY;
+        }
+        let raw;
+        try {
+            raw = JSON.parse(stdinText);
+        }
+        catch {
+            raw = undefined;
+        }
+        if (typeof raw === 'object' && raw !== null && 'session_id' in raw) {
+            const s = raw.session_id;
+            if (typeof s === 'string')
+                session = s;
+        }
+        if (event === 'UserPromptSubmit') {
+            const p = UserPromptSubmitInput.safeParse(raw);
+            if (p.success)
+                return await handleUserPromptSubmit(p.data, deps);
+        }
+        else if (event === 'Stop') {
+            const p = StopInput.safeParse(raw);
+            if (p.success)
+                return await handleStop(p.data, deps);
+        }
+        else if (event === 'SessionStart') {
+            const p = SessionStartInput.safeParse(raw);
+            if (p.success)
+                return await handleSessionStart(p.data, deps);
+        }
+        deps.log.write({
+            event,
+            session,
+            project: null,
+            outcome: 'invalid-input',
+            counts: {},
+            timings: {},
+        });
+        return EMPTY;
+    }
+    catch {
+        try {
+            deps.log.write({ event, session, project: null, outcome: 'error', counts: {}, timings: {} });
+        }
+        catch {
+            // Nothing left to do; the session must go on.
+        }
+        return EMPTY;
+    }
+}
+//# sourceMappingURL=hooks.js.map

package/dist/import.d.ts

@@ -0,0 +1,71 @@
+import { type ObserveResult } from '@oortmem/core';
+import type { HookDeps } from './deps.js';
+export interface ImportOptions {
+    /** Claude Code's projects directory, usually `~/.claude/projects`. */
+    projectsDir: string;
+    /** Only transcripts modified at or after this time. */
+    since?: Date;
+    /** Count and estimate only; write nothing. */
+    estimateOnly: boolean;
+    /** Share of observations expected to reach the writer (after the gate). Default 0.25. */
+    writerFraction?: number;
+    /**
+     * Import sessions whose project cannot be resolved into global scope.
+     * Default false: they are skipped, since a deleted private project's
+     * memories would otherwise surface in every project.
+     */
+    includeUnresolved?: boolean;
+}
+export interface ImportResult {
+    /** Sessions with at least one observation to import. */
+    sessions: number;
+    observations: number;
+    /** Writer tokens: Σ(chars / 4 + 400) × writerFraction. No price table in Phase 1. */
+    estimatedTokens: number;
+    /**
+     * Sessions with observations that were left out because their project could
+     * not be resolved (recorded `cwd` gone, or not in a git repository).
+     */
+    skippedUnresolved: number;
+    /** Transcripts that vanished or could not be read during the walk. */
+    skippedUnreadable: number;
+    results?: ObserveResult[];
+    /** Per-outcome counts, plus `failed` for observations whose observe threw. */
+    outcomes?: Record<string, number>;
+    /**
+     * Sessions that stopped at a failed observation: its cursor stays before it,
+     * and the session's later observations were not attempted (the Stop hook or
+     * a later import picks them up).
+     */
+    failedSessions?: Record<string, {
+        failed: number;
+        notAttempted: number;
+        reason: string;
+    }>;
+    /**
+     * Observations skipped because the failure is permanent for that input (the
+     * writer's output never fits the schema, or the model refused or truncated),
+     * keyed by `failureReason`. Their sessions continue and the cursor passes them.
+     */
+    unwritable?: Record<string, number>;
+}
+/**
+ * Why an observation failed, from the error's class and the typed fields our
+ * adapters set (`kind`, `status`, `fields`). Never the message: a provider's
+ * message may echo the observation it was given.
+ */
+export declare function failureReason(e: unknown): string;
+/**
+ * Imports existing Claude Code transcripts. Every transcript is parsed,
+ * paired and scrubbed; turns already behind a session's cursor (observed by
+ * the Stop hook or an earlier import) are skipped. With `estimateOnly` it
+ * only reports the estimate. Otherwise it observes oldest first across all
+ * sessions, advances each session's cursor so the Stop hook never re-observes
+ * imported turns, and appends one eval row per added memory to
+ * `$OORT_HOME/eval/import-<YYYY-MM-DD>.jsonl`.
+ *
+ * The scope of each transcript is derived from the `cwd` its rows recorded.
+ * A session whose project cannot be resolved is skipped (and counted in
+ * `skippedUnresolved`) unless `includeUnresolved` imports it as global.
+ */
+export declare function importTranscripts(opts: ImportOptions, deps: HookDeps): Promise<ImportResult>;

package/dist/import.js

@@ -0,0 +1,244 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { appendPrivateFile, localScope, observe, resolveProjectId, scrubObservation, } from '@oortmem/core';
+import { cursorKey, grantFor } from './hooks.js';
+import { parseTranscriptDetailed, selectAfterCursor } from './transcript.js';
+/** A failure a re-run would repeat for the same observation: skip it rather than stop the session. */
+function isPermanent(e) {
+    if (!(e instanceof Error))
+        return false;
+    if (e.name === 'WriterOutputError')
+        return true;
+    return e.name === 'WriterError' && e.kind === 'bad-response';
+}
+/**
+ * Why an observation failed, from the error's class and the typed fields our
+ * adapters set (`kind`, `status`, `fields`). Never the message: a provider's
+ * message may echo the observation it was given.
+ */
+export function failureReason(e) {
+    if (!(e instanceof Error))
+        return 'non-error thrown';
+    const { kind, status, fields } = e;
+    const parts = [];
+    if (typeof kind === 'string')
+        parts.push(kind);
+    if (typeof status === 'number')
+        parts.push(`HTTP ${status}`);
+    if (Array.isArray(fields) && fields.every((f) => typeof f === 'string'))
+        parts.push(`fields: ${fields.join(', ')}`);
+    return parts.length === 0 ? e.name : `${e.name} (${parts.join(', ')})`;
+}
+/** Fixed per-call writer overhead (system prompt, schema), in tokens. */
+const WRITER_OVERHEAD_TOKENS = 400;
+const DEFAULT_WRITER_FRACTION = 0.25;
+/**
+ * Session transcripts: `<projectsDir>/<project>/<session>.jsonl`. Subagent
+ * transcripts (one level deeper) and orphaned copies Claude Code set aside
+ * (`<session>.orphaned-…jsonl`) are not sessions of their own.
+ */
+function transcripts(projectsDir, since, skip) {
+    const out = [];
+    let projects;
+    try {
+        projects = fs.readdirSync(projectsDir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const p of projects) {
+        if (!p.isDirectory())
+            continue;
+        const dir = path.join(projectsDir, p.name);
+        let files;
+        try {
+            files = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (!f.isFile() || !f.name.endsWith('.jsonl') || f.name.includes('.orphaned-'))
+                continue;
+            const file = path.join(dir, f.name);
+            if (since !== undefined) {
+                let mtime;
+                try {
+                    mtime = fs.statSync(file).mtimeMs;
+                }
+                catch {
+                    skip(); // Vanished mid-walk.
+                    continue;
+                }
+                if (mtime < since.getTime())
+                    continue;
+            }
+            out.push(file);
+        }
+    }
+    return out.sort();
+}
+/**
+ * The session's project id, or undefined when it cannot be resolved. A missing
+ * directory is unresolved even inside a git repo: walking up from it would
+ * attribute the session to the enclosing repository instead.
+ */
+function resolveProject(cwd, home) {
+    if (cwd === undefined || !fs.existsSync(cwd))
+        return undefined;
+    return resolveProjectId(cwd, home);
+}
+function chars(o) {
+    return (o.userText.length + o.assistantText.length + o.toolSummaries.reduce((n, s) => n + s.length, 0));
+}
+/**
+ * Imports existing Claude Code transcripts. Every transcript is parsed,
+ * paired and scrubbed; turns already behind a session's cursor (observed by
+ * the Stop hook or an earlier import) are skipped. With `estimateOnly` it
+ * only reports the estimate. Otherwise it observes oldest first across all
+ * sessions, advances each session's cursor so the Stop hook never re-observes
+ * imported turns, and appends one eval row per added memory to
+ * `$OORT_HOME/eval/import-<YYYY-MM-DD>.jsonl`.
+ *
+ * The scope of each transcript is derived from the `cwd` its rows recorded.
+ * A session whose project cannot be resolved is skipped (and counted in
+ * `skippedUnresolved`) unless `includeUnresolved` imports it as global.
+ */
+export async function importTranscripts(opts, deps) {
+    const items = [];
+    let weighted = 0;
+    const sessions = new Set();
+    let skippedUnresolved = 0;
+    let skippedUnreadable = 0;
+    const skip = () => {
+        skippedUnreadable++;
+    };
+    for (const file of transcripts(opts.projectsDir, opts.since, skip)) {
+        const session = path.basename(file, '.jsonl');
+        let text;
+        try {
+            text = fs.readFileSync(file, 'utf8');
+        }
+        catch {
+            skip();
+            continue;
+        }
+        const detailed = parseTranscriptDetailed(text);
+        const cwd = detailed.find((d) => d.turn.cwd.length > 0)?.turn.cwd;
+        const projectId = resolveProject(cwd, deps.config.home);
+        const scope = localScope(projectId);
+        const { fresh } = selectAfterCursor(detailed, await deps.store.getCursor(grantFor(scope), cursorKey(session)));
+        const mine = [];
+        for (const raw of fresh) {
+            const s = scrubObservation(raw);
+            if (s.dropped)
+                continue;
+            mine.push({ session, pos: mine.length, obs: s.obs, scope });
+        }
+        if (mine.length === 0)
+            continue;
+        if (projectId === undefined && opts.includeUnresolved !== true) {
+            skippedUnresolved++;
+            continue;
+        }
+        for (const item of mine)
+            weighted += chars(item.obs) / 4 + WRITER_OVERHEAD_TOKENS;
+        items.push(...mine);
+        sessions.add(session);
+    }
+    const fraction = opts.writerFraction ?? DEFAULT_WRITER_FRACTION;
+    const summary = {
+        sessions: sessions.size,
+        observations: items.length,
+        estimatedTokens: Math.ceil(weighted * fraction),
+        skippedUnresolved,
+        skippedUnreadable,
+    };
+    if (opts.estimateOnly)
+        return summary;
+    const { embed, decide, write } = deps;
+    if (embed === undefined || decide === undefined || write === undefined) {
+        throw new Error('import needs the embed, decide and write adapters');
+    }
+    // Oldest first across sessions, but never out of order within one: each item
+    // sorts at its session's running maximum timestamp (the sort is stable).
+    const runningMax = new Map();
+    const key = new Map();
+    for (const item of items) {
+        const t = Date.parse(item.obs.at);
+        const k = Math.max(runningMax.get(item.session) ?? 0, Number.isNaN(t) ? 0 : t);
+        runningMax.set(item.session, k);
+        key.set(item, k);
+    }
+    items.sort((a, b) => (key.get(a) ?? 0) - (key.get(b) ?? 0));
+    const day = (deps.now?.() ?? new Date()).toISOString().slice(0, 10);
+    const evalFile = path.join(deps.config.home, 'eval', `import-${day}.jsonl`);
+    const results = [];
+    const outcomes = {};
+    const failedSessions = {};
+    const unwritable = {};
+    const done = new Map();
+    // Only forward within a session, and only past observations that are finished with.
+    const advance = async (item) => {
+        const prev = done.get(item.session) ?? -1;
+        if (item.pos > prev && item.obs.turnRef !== undefined) {
+            await deps.store.setCursor(grantFor(item.scope), cursorKey(item.session), item.obs.turnRef);
+            done.set(item.session, item.pos);
+        }
+    };
+    for (const item of items) {
+        const stopped = failedSessions[item.session];
+        if (stopped !== undefined) {
+            // The session stopped at an earlier failure; its cursor must not pass it.
+            stopped.notAttempted++;
+            continue;
+        }
+        let r;
+        try {
+            r = await observe(item.obs, item.scope, {
+                store: deps.store,
+                embed,
+                decide,
+                write,
+                config: deps.config,
+                now: deps.now?.() ?? new Date(),
+                harness: 'claude-code',
+            });
+        }
+        catch (e) {
+            if (isPermanent(e)) {
+                outcomes['unwritable'] = (outcomes['unwritable'] ?? 0) + 1;
+                const why = failureReason(e);
+                unwritable[why] = (unwritable[why] ?? 0) + 1;
+                await advance(item);
+                continue;
+            }
+            outcomes['failed'] = (outcomes['failed'] ?? 0) + 1;
+            failedSessions[item.session] = { failed: 1, notAttempted: 0, reason: failureReason(e) };
+            continue;
+        }
+        results.push(r);
+        // A turn can become several memories (CON-56): count and log each one.
+        for (const m of r.memories) {
+            outcomes[m.outcome] = (outcomes[m.outcome] ?? 0) + 1;
+            if (m.outcome !== 'added' || m.memoryId === undefined)
+                continue;
+            const row = {
+                memoryId: m.memoryId,
+                question: '',
+                expectedMemoryIds: [m.memoryId],
+                asOf: item.obs.at,
+            };
+            appendPrivateFile(evalFile, `${JSON.stringify(row)}\n`);
+        }
+        await advance(item);
+    }
+    return {
+        ...summary,
+        results,
+        outcomes,
+        ...(Object.keys(failedSessions).length > 0 && { failedSessions }),
+        ...(Object.keys(unwritable).length > 0 && { unwritable }),
+    };
+}
+//# sourceMappingURL=import.js.map

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { HookDeps, RemoteMemory } from './deps.js';
+export { createHookLogger, HOOK_LOG_MAX_BYTES, type HookLogEntry, type HookLogger } from './log.js';
+export { HARNESS_TAGS, OORT_MEMORY_TAG, parseTranscript, parseTranscriptDetailed, selectAfterCursor, turnsToObservations, type DetailedTurn, type Turn, } from './transcript.js';
+export { cursorKey, filterFor, grantFor, handleSessionStart, handleStop, handleUserPromptSubmit, RECALL_TIMEOUT_MS, runHook, STOP_MAX_OBSERVATIONS, type HookEvent, type HookOutput, } from './hooks.js';
+export { drainQueue, enqueueObservations, queueDir, type DrainResult, type QueueLine, } from './queue.js';
+export { HOOK_EVENTS, HOOK_TIMEOUTS, hookStatus, installHooks, uninstallHooks, type HookEventStatus, } from './install.js';
+export { importTranscripts, type ImportOptions, type ImportResult } from './import.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { createHookLogger, HOOK_LOG_MAX_BYTES } from './log.js';
+export { HARNESS_TAGS, OORT_MEMORY_TAG, parseTranscript, parseTranscriptDetailed, selectAfterCursor, turnsToObservations, } from './transcript.js';
+export { cursorKey, filterFor, grantFor, handleSessionStart, handleStop, handleUserPromptSubmit, RECALL_TIMEOUT_MS, runHook, STOP_MAX_OBSERVATIONS, } from './hooks.js';
+export { drainQueue, enqueueObservations, queueDir, } from './queue.js';
+export { HOOK_EVENTS, HOOK_TIMEOUTS, hookStatus, installHooks, uninstallHooks, } from './install.js';
+export { importTranscripts } from './import.js';
+//# sourceMappingURL=index.js.map