fluffy-context 0.3.0 → 0.5.0

package/dist/src/cognition/runtime.js

@@ -0,0 +1,295 @@
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createConnection, createServer } from 'node:net';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { resolveProjectRoot } from '../project/project-resolver.js';
+import { loadManifest } from '../runtime/init.js';
+import { atomicWriteJson } from '../storage/atomic-write.js';
+import { readJson } from '../storage/json-store.js';
+import { withLock } from '../storage/lock.js';
+import { cognitionManifestPath, cognitionPolicyPath, cognitionRuntimeLeasePath, cognitionRuntimeSecretPath, locksDirectory } from '../storage/layout.js';
+import { appendEvent } from './journal.js';
+import { GitObserver } from './git-observer.js';
+import { reconcileV1State } from './migration-v1.js';
+import { v1Synced } from './v1-bridge.js';
+const host = '127.0.0.1';
+const protocolVersion = 1;
+const maxFrameBytes = 16 * 1024;
+const pollIntervalMs = 2_000;
+const cliPath = fileURLToPath(new URL('../cli/main.js', import.meta.url));
+function createInstanceId() {
+    return crypto.randomBytes(12).toString('hex');
+}
+function createToken() {
+    return crypto.randomBytes(32).toString('base64url');
+}
+function sameToken(left, right) {
+    const expected = Buffer.from(left);
+    const actual = Buffer.from(right);
+    return expected.length === actual.length && crypto.timingSafeEqual(expected, actual);
+}
+function publicLease(lease) {
+    const { projectId: _, ...visible } = lease;
+    return visible;
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function loadPolicy(projectRoot) {
+    return readJson(cognitionPolicyPath(projectRoot));
+}
+async function loadLease(projectRoot) {
+    return readJson(cognitionRuntimeLeasePath(projectRoot)).catch(() => null);
+}
+async function request(projectRoot, lease, method) {
+    let secret;
+    try {
+        secret = (await readFile(cognitionRuntimeSecretPath(projectRoot), 'utf8')).trim();
+    }
+    catch {
+        return null;
+    }
+    if (!secret || lease.host !== host || !Number.isInteger(lease.port) || lease.port <= 0)
+        return null;
+    return new Promise((resolve) => {
+        const socket = createConnection({ host, port: lease.port });
+        let buffer = '';
+        const timeout = setTimeout(() => { socket.destroy(); resolve(null); }, 1_000);
+        socket.setEncoding('utf8');
+        socket.once('error', () => { clearTimeout(timeout); resolve(null); });
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            const boundary = buffer.indexOf('\n');
+            if (boundary < 0)
+                return;
+            clearTimeout(timeout);
+            socket.end();
+            try {
+                resolve(JSON.parse(buffer.slice(0, boundary)));
+            }
+            catch {
+                resolve(null);
+            }
+        });
+        socket.on('connect', () => socket.write(`${JSON.stringify({ token: secret, method })}\n`));
+    });
+}
+async function liveLease(projectRoot, lease) {
+    const candidate = lease === undefined ? await loadLease(projectRoot) : lease;
+    if (!candidate)
+        return null;
+    const response = await request(projectRoot, candidate, 'ping');
+    return response?.ok ? candidate : null;
+}
+async function writeLease(projectRoot, lease) {
+    await atomicWriteJson(cognitionRuntimeLeasePath(projectRoot), lease);
+}
+async function closeServer(projectRoot, server, observer, heartbeat, poller, inactivity, lease, reason) {
+    clearInterval(heartbeat);
+    clearInterval(poller);
+    clearTimeout(inactivity);
+    await observer.drain();
+    await new Promise((resolve) => server.close(() => resolve()));
+    await new Promise((resolve) => setImmediate(resolve));
+    await rm(cognitionRuntimeLeasePath(projectRoot), { force: true });
+    await rm(cognitionRuntimeSecretPath(projectRoot), { force: true });
+    await appendEvent(projectRoot, {
+        type: 'runtime.stopped',
+        source: { kind: 'cli', instanceId: lease.instanceId },
+        idempotencyKey: `runtime:stopped:${lease.instanceId}`,
+        payload: { reason },
+    });
+}
+function attachProtocol(projectRoot, server, observer, secret, lease, touch, close) {
+    server.on('connection', (socket) => {
+        socket.setEncoding('utf8');
+        let buffer = '';
+        socket.on('data', async (chunk) => {
+            buffer += chunk;
+            if (Buffer.byteLength(buffer) > maxFrameBytes) {
+                socket.destroy();
+                return;
+            }
+            const boundary = buffer.indexOf('\n');
+            if (boundary < 0)
+                return;
+            const frame = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 1);
+            let request;
+            try {
+                request = JSON.parse(frame);
+            }
+            catch {
+                socket.end('{"ok":false,"error":"invalid_request"}\n');
+                return;
+            }
+            if (!request.token || !sameToken(request.token, secret)) {
+                socket.end('{"ok":false,"error":"unauthorized"}\n');
+                return;
+            }
+            touch();
+            if (request.method === 'ping') {
+                socket.end(`${JSON.stringify({ ok: true, result: { instanceId: lease.instanceId } })}\n`);
+                return;
+            }
+            if (request.method === 'observe') {
+                try {
+                    const result = await observer.observeNow();
+                    socket.end(`${JSON.stringify({ ok: true, result: { changed: result.changed } })}\n`);
+                }
+                catch {
+                    socket.end('{"ok":false,"error":"observe_failed"}\n');
+                }
+                return;
+            }
+            if (request.method === 'stop') {
+                socket.end('{"ok":true}\n');
+                void close('ipc');
+                return;
+            }
+            socket.end('{"ok":false,"error":"unknown_method"}\n');
+        });
+    });
+}
+export async function serveRuntime(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const currentPolicy = await loadPolicy(projectRoot);
+    if (!currentPolicy.enabled)
+        throw new Error('runtime is disabled; run ctx runtime enable first');
+    const existing = await liveLease(projectRoot);
+    if (existing)
+        throw new Error('runtime is already running');
+    const server = createServer();
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, host, () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        server.close();
+        throw new Error('runtime failed to bind loopback endpoint');
+    }
+    const manifest = await loadManifest(projectRoot);
+    const now = new Date().toISOString();
+    const lease = { schemaVersion: 2, protocolVersion, projectId: manifest.projectId, instanceId: createInstanceId(), pid: process.pid, host, port: address.port, startedAt: now, heartbeatAt: now };
+    const secret = createToken();
+    const observer = new GitObserver(projectRoot);
+    let closed = false;
+    let heartbeat;
+    let poller;
+    let inactivity;
+    const close = async (reason) => {
+        if (closed)
+            return;
+        closed = true;
+        await closeServer(projectRoot, server, observer, heartbeat, poller, inactivity, lease, reason);
+    };
+    const touch = () => {
+        clearTimeout(inactivity);
+        inactivity = setTimeout(() => { void close('inactivity'); }, currentPolicy.inactivityTimeoutMs);
+    };
+    attachProtocol(projectRoot, server, observer, secret, lease, touch, close);
+    try {
+        await withLock(`${locksDirectory(projectRoot)}/cognition-runtime-start.lock`, async () => {
+            const live = await liveLease(projectRoot);
+            if (live)
+                throw new Error('runtime is already running');
+            await mkdir(path.dirname(cognitionRuntimeSecretPath(projectRoot)), { recursive: true });
+            await writeFile(cognitionRuntimeSecretPath(projectRoot), secret, { encoding: 'utf8', mode: 0o600 });
+            await writeLease(projectRoot, lease);
+        });
+    }
+    catch (error) {
+        await new Promise((resolve) => server.close(() => resolve()));
+        throw error;
+    }
+    heartbeat = setInterval(() => {
+        lease.heartbeatAt = new Date().toISOString();
+        void writeLease(projectRoot, lease);
+    }, 5_000);
+    poller = setInterval(() => {
+        void observer.observeNow();
+        void v1Synced(projectRoot).then((synced) => { if (!synced)
+            return reconcileV1State(projectRoot); });
+    }, pollIntervalMs);
+    touch();
+    await appendEvent(projectRoot, { type: 'runtime.started', source: { kind: 'cli', instanceId: lease.instanceId }, idempotencyKey: `runtime:started:${lease.instanceId}`, payload: {} });
+    await observer.observeNow();
+    return { lease, close };
+}
+export async function runtimeStatus(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const migrated = await exists(cognitionManifestPath(projectRoot));
+    if (!migrated)
+        return { projectRoot, v2Present: false, enabled: false, migrated: false, running: false, lease: null };
+    const runtimePolicy = await loadPolicy(projectRoot);
+    const lease = await loadLease(projectRoot);
+    const live = await liveLease(projectRoot, lease);
+    return { projectRoot, v2Present: true, enabled: runtimePolicy.enabled, migrated: true, running: Boolean(live), lease: lease ? publicLease(lease) : null };
+}
+export async function enableRuntime(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    if (!await exists(cognitionManifestPath(projectRoot)))
+        throw new Error('v2 migration is required before enabling the runtime');
+    const current = await loadPolicy(projectRoot);
+    if (!current.enabled) {
+        await atomicWriteJson(cognitionPolicyPath(projectRoot), { ...current, enabled: true });
+        await appendEvent(projectRoot, { type: 'runtime.enabled', source: { kind: 'cli' }, idempotencyKey: 'runtime:enabled', payload: {} });
+    }
+    return runtimeStatus(projectRoot);
+}
+export async function disableRuntime(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    if (!await exists(cognitionManifestPath(projectRoot)))
+        throw new Error('v2 migration is required before disabling the runtime');
+    await stopRuntime(projectRoot);
+    const current = await loadPolicy(projectRoot);
+    await atomicWriteJson(cognitionPolicyPath(projectRoot), { ...current, enabled: false });
+    return runtimeStatus(projectRoot);
+}
+export async function startRuntime(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const current = await loadPolicy(projectRoot);
+    if (!current.enabled)
+        throw new Error('runtime is disabled; run ctx runtime enable first');
+    if (await liveLease(projectRoot))
+        return runtimeStatus(projectRoot);
+    const child = spawn(process.execPath, [cliPath, 'runtime', 'serve', '--path', projectRoot], { detached: true, stdio: 'ignore', windowsHide: true });
+    child.unref();
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        const status = await runtimeStatus(projectRoot);
+        if (status.running)
+            return status;
+    }
+    throw new Error('runtime failed to start');
+}
+export async function stopRuntime(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const lease = await liveLease(projectRoot);
+    if (!lease)
+        return runtimeStatus(projectRoot);
+    await request(projectRoot, lease, 'stop');
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        const status = await runtimeStatus(projectRoot);
+        if (!status.running)
+            return status;
+    }
+    throw new Error('runtime failed to stop');
+}
+export async function observeRuntime(startPath) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    const lease = await liveLease(projectRoot);
+    if (!lease)
+        return false;
+    return Boolean((await request(projectRoot, lease, 'observe'))?.ok);
+}

package/dist/src/cognition/types.d.ts

@@ -0,0 +1,132 @@
+export declare const COGNITION_LAYOUT_VERSION: "event-journal-v2";
+export type CognitionEventSource = 'cli' | 'claude-hook' | 'mcp' | 'git-observer' | 'fs-observer' | 'migration';
+export type CognitionEventType = 'runtime.enabled' | 'runtime.started' | 'runtime.stopped' | 'host.session.started' | 'host.prompt.submitted' | 'git.state.observed' | 'git.branch.changed' | 'git.head.changed' | 'workspace.paths.changed' | 'context.checkpoint.imported' | 'context.state.recorded' | 'note.recorded' | 'note.resolved' | 'note.absorbed' | 'knowledge.proposed' | 'knowledge.verified' | 'knowledge.deprecated' | 'deadend.proposed' | 'deadend.verified' | 'deadend.obsoleted' | 'projection.advanced' | 'projection.failed';
+export interface CognitionGitAnchor {
+    worktreeId: string | null;
+    branch: string | null;
+    ref: string | null;
+    head: string | null;
+}
+export interface CognitionEvent<T = Record<string, unknown>> {
+    eventId: string;
+    schemaVersion: 2;
+    type: CognitionEventType;
+    occurredAt: string;
+    observedAt: string;
+    projectId: string;
+    source: {
+        kind: CognitionEventSource;
+        instanceId?: string;
+    };
+    correlationId?: string;
+    idempotencyKey: string;
+    git: CognitionGitAnchor;
+    privacy: {
+        classification: 'metadata' | 'redacted-text';
+        redactionCount: number;
+    };
+    payload: T;
+    previousHash: string | null;
+    hash: string;
+}
+export interface CognitionRuntimePolicy {
+    schemaVersion: 2;
+    enabled: boolean;
+    allowHookStartup: boolean;
+    inactivityTimeoutMs: number;
+    promptIntentMaxChars: number;
+    filesystemEventsEnabled: boolean;
+    retentionMaxBytes: number;
+}
+export interface CognitionManifest {
+    schemaVersion: 2;
+    layoutVersion: typeof COGNITION_LAYOUT_VERSION;
+    projectId: string;
+    createdAt: string;
+    policyVersion: 1;
+}
+export interface Applicability {
+    project: true;
+    branches?: string[];
+    branchMode: 'global' | 'exact' | 'ancestor-of-source' | 'descendant-of-source';
+    paths?: string[];
+    sourceCommit?: string | null;
+    dependencyConstraints?: string[];
+}
+export interface BranchWorkspace {
+    schemaVersion: 2;
+    workspaceKey: string;
+    worktreeId: string | null;
+    branch: string | null;
+    ref: string | null;
+    head: string | null;
+    activeContextRef: string | null;
+    openObservationEventIds: string[];
+    pathFocus: string[];
+    recentEventIds: string[];
+    lastActivatedAt: string;
+}
+export interface ProjectionCursor {
+    schemaVersion: 2;
+    lastEventId: string | null;
+    lastEventHash: string | null;
+    updatedAt: string | null;
+}
+export interface MigrationReadiness {
+    projectRoot: string;
+    eligible: boolean;
+    v1Present: boolean;
+    v2Present: boolean;
+    counts: {
+        contexts: number;
+        snapshots: number;
+        notes: number;
+        knowledge: number;
+        deadends: number;
+    };
+    issues: string[];
+}
+export interface V1ImportReceipt {
+    schemaVersion: 2;
+    sourceHash: string;
+    importedAt: string;
+    eventIds: string[];
+    counts: MigrationReadiness['counts'];
+}
+export interface MigrationReport extends MigrationReadiness {
+    applied: boolean;
+    importedEventIds: string[];
+}
+export interface CognitionRecordPayload<T extends Record<string, unknown> = Record<string, unknown>> {
+    record: T;
+    sourcePath?: string;
+    sourceHash?: string;
+    anchorProvenance?: 'snapshot' | 'live' | 'global';
+}
+export interface CognitionProjection {
+    schemaVersion: 2;
+    contexts: Record<string, CognitionRecordPayload>;
+    notes: Record<string, CognitionRecordPayload>;
+    knowledge: Record<string, CognitionRecordPayload>;
+    deadends: Record<string, CognitionRecordPayload>;
+    workspaces: Record<string, BranchWorkspace>;
+}
+export interface RuntimeLease {
+    schemaVersion: 2;
+    protocolVersion: 1;
+    projectId: string;
+    instanceId: string;
+    pid: number;
+    host: '127.0.0.1';
+    port: number;
+    startedAt: string;
+    heartbeatAt: string;
+}
+export interface RuntimeStatus {
+    projectRoot: string;
+    v2Present: boolean;
+    enabled: boolean;
+    migrated: boolean;
+    running: boolean;
+    lease: Omit<RuntimeLease, 'projectId'> | null;
+}

package/dist/src/cognition/types.js

@@ -0,0 +1 @@
+export const COGNITION_LAYOUT_VERSION = 'event-journal-v2';

package/dist/src/cognition/v1-bridge.d.ts

@@ -0,0 +1,7 @@
+import type { ContextMetadata, Deadend, Knowledge, Note, Snapshot } from '../runtime/types.js';
+export declare function v1Fingerprint(projectRoot: string): Promise<string>;
+export declare function v1Synced(projectRoot: string): Promise<boolean>;
+export declare function mirrorCheckpoint(projectRoot: string, context: ContextMetadata, snapshot: Snapshot): Promise<void>;
+export declare function mirrorNote(projectRoot: string, note: Note, absorbed?: boolean): Promise<void>;
+export declare function mirrorKnowledge(projectRoot: string, knowledge: Knowledge): Promise<void>;
+export declare function mirrorDeadend(projectRoot: string, deadend: Deadend): Promise<void>;

package/dist/src/cognition/v1-bridge.js

@@ -0,0 +1,74 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { access, readFile, readdir } from 'node:fs/promises';
+import { readGitWorktreeState } from '../git/git-adapter.js';
+import { cognitionManifestPath, cognitionPolicyPath, cognitionV1SyncPath, contextsRoot, deadendsPath, knowledgePath, notesPath, snapshotsDirectory } from '../storage/layout.js';
+import { readJson } from '../storage/json-store.js';
+import { atomicWriteJson } from '../storage/atomic-write.js';
+import { appendEvent } from './journal.js';
+import { rebuildProjections } from './projections.js';
+function digest(record) {
+    return crypto.createHash('sha256').update(JSON.stringify(record)).digest('hex');
+}
+export async function v1Fingerprint(projectRoot) {
+    const files = [notesPath(projectRoot), knowledgePath(projectRoot), deadendsPath(projectRoot)];
+    const contextIds = await readdir(contextsRoot(projectRoot)).catch(() => []);
+    const contextFiles = contextIds.map((contextId) => path.join(contextsRoot(projectRoot), contextId, 'context.json'));
+    const snapshots = (await Promise.all(contextIds.map(async (contextId) => {
+        const directory = snapshotsDirectory(projectRoot, contextId);
+        const files = await readdir(directory).catch(() => []);
+        return files.filter((file) => file.endsWith('.json')).map((file) => path.join(directory, file));
+    }))).flat();
+    const contents = await Promise.all([...files, ...contextFiles, ...snapshots].map(async (file) => readFile(file, 'utf8').catch(() => '')));
+    return digest(contents);
+}
+export async function v1Synced(projectRoot) {
+    try {
+        const [current, cursor] = await Promise.all([v1Fingerprint(projectRoot), readJson(cognitionV1SyncPath(projectRoot))]);
+        return current === cursor.fingerprint;
+    }
+    catch {
+        return false;
+    }
+}
+async function enabled(projectRoot) {
+    try {
+        await access(cognitionManifestPath(projectRoot));
+        return (await readJson(cognitionPolicyPath(projectRoot))).enabled;
+    }
+    catch {
+        return false;
+    }
+}
+async function mirror(projectRoot, type, record, identity) {
+    if (!await enabled(projectRoot))
+        return;
+    try {
+        const state = await readGitWorktreeState(projectRoot);
+        const { appended } = await appendEvent(projectRoot, {
+            type,
+            source: { kind: 'cli' },
+            idempotencyKey: `v1-live:${type}:${identity}:${digest(record)}`,
+            git: { worktreeId: state.worktreeId, branch: state.branch, ref: state.ref, head: state.commit },
+            payload: { record, anchorProvenance: 'live' },
+        });
+        if (appended)
+            await rebuildProjections(projectRoot);
+        await atomicWriteJson(cognitionV1SyncPath(projectRoot), { schemaVersion: 2, fingerprint: await v1Fingerprint(projectRoot), updatedAt: new Date().toISOString() });
+    }
+    catch {
+        // v1 remains authoritative when v2 mirroring is unavailable.
+    }
+}
+export async function mirrorCheckpoint(projectRoot, context, snapshot) {
+    await mirror(projectRoot, 'context.state.recorded', { context, snapshot }, `${context.id}:${snapshot.snapshotId}`);
+}
+export async function mirrorNote(projectRoot, note, absorbed = false) {
+    await mirror(projectRoot, absorbed ? 'note.absorbed' : 'note.recorded', note, note.noteId);
+}
+export async function mirrorKnowledge(projectRoot, knowledge) {
+    await mirror(projectRoot, knowledge.status === 'verified' ? 'knowledge.verified' : 'knowledge.proposed', knowledge, knowledge.knowledgeId);
+}
+export async function mirrorDeadend(projectRoot, deadend) {
+    await mirror(projectRoot, deadend.status === 'verified' ? 'deadend.verified' : 'deadend.proposed', deadend, deadend.deadendId);
+}

package/dist/src/git/git-adapter.d.ts

@@ -1,2 +1,9 @@
 import type { GitState } from '../runtime/types.js';
+export interface GitWorktreeState extends GitState {
+    ref: string | null;
+    detached: boolean;
+    worktreeId: string | null;
+    fingerprint: string | null;
+}
 export declare function readGitState(projectRoot: string): Promise<GitState>;
+export declare function readGitWorktreeState(projectRoot: string): Promise<GitWorktreeState>;

package/dist/src/git/git-adapter.js

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
@@ -11,13 +12,22 @@ async function git(args, cwd) {
     }
 }
 export async function readGitState(projectRoot) {
+    const state = await readGitWorktreeState(projectRoot);
+    return { root: state.root, branch: state.branch, commit: state.commit };
+}
+export async function readGitWorktreeState(projectRoot) {
     const root = await git(['rev-parse', '--show-toplevel'], projectRoot);
     if (!root) {
-        return { root: null, branch: null, commit: null };
+        return { root: null, branch: null, commit: null, ref: null, detached: false, worktreeId: null, fingerprint: null };
     }
-    return {
-        root,
-        branch: await git(['branch', '--show-current'], projectRoot),
-        commit: await git(['rev-parse', 'HEAD'], projectRoot),
-    };
+    const [branch, commit, ref, gitDir] = await Promise.all([
+        git(['branch', '--show-current'], projectRoot),
+        git(['rev-parse', 'HEAD'], projectRoot),
+        git(['symbolic-ref', '--quiet', '--short', 'HEAD'], projectRoot),
+        git(['rev-parse', '--git-dir'], projectRoot),
+    ]);
+    const detached = ref === null;
+    const worktreeId = crypto.createHash('sha256').update(`${root}\0${gitDir ?? projectRoot}`).digest('hex').slice(0, 16);
+    const fingerprint = crypto.createHash('sha256').update(`${worktreeId}\0${ref ?? 'detached'}\0${commit ?? 'missing'}`).digest('hex').slice(0, 16);
+    return { root, branch, commit, ref, detached, worktreeId, fingerprint };
 }

package/dist/src/hooks/claude-code.js

@@ -1,4 +1,11 @@
 import { contextOrient } from '../agent/api.js';
+import { appendEvent } from '../cognition/journal.js';
+import { v2Enabled } from '../cognition/orient.js';
+import { startRuntime } from '../cognition/runtime.js';
+import { readGitWorktreeState } from '../git/git-adapter.js';
+import { resolveProjectRoot } from '../project/project-resolver.js';
+import { cognitionPolicyPath } from '../storage/layout.js';
+import { readJson } from '../storage/json-store.js';
 const HOOK_RESPONSE = '{}\n';
 function text(value) {
     return typeof value === 'string' ? value : undefined;
@@ -51,6 +58,49 @@ function promptContext(result) {
     }
     return phases.join('\n');
 }
+function stableId(input, name) {
+    return name === 'session' ? text(input.session_id) ?? text(input.sessionId) : text(input.event_id) ?? text(input.eventId);
+}
+function redactIntent(value) {
+    let redactionCount = 0;
+    const intent = value
+        .replace(/(?:api[_-]?key|token|password|secret)\s*[:=]\s*\S+/gi, () => { redactionCount += 1; return '[REDACTED]'; })
+        .replace(/\b(?:sk|ghp|gho|github_pat)_[A-Za-z0-9_-]+\b/g, () => { redactionCount += 1; return '[REDACTED]'; });
+    return { intent, redactionCount };
+}
+async function within(task, milliseconds) {
+    return Promise.race([task, new Promise((_, reject) => setTimeout(() => reject(new Error('hook deadline exceeded')), milliseconds))]);
+}
+async function capture(event, input) {
+    const cwd = text(input.cwd);
+    const projectRoot = await resolveProjectRoot(cwd);
+    if (!await v2Enabled(projectRoot))
+        return;
+    const policy = await readJson(cognitionPolicyPath(projectRoot));
+    const sessionId = stableId(input, 'session');
+    const eventId = stableId(input, 'event');
+    if (!sessionId || !eventId)
+        return;
+    const state = await readGitWorktreeState(projectRoot);
+    const captured = event === 'user-prompt' ? redactIntent(compact(text(input.prompt) ?? '', policy.promptIntentMaxChars)) : { intent: '', redactionCount: 0 };
+    await appendEvent(projectRoot, {
+        type: event === 'session-start' ? 'host.session.started' : 'host.prompt.submitted',
+        source: { kind: 'claude-hook', instanceId: sessionId },
+        correlationId: sessionId,
+        idempotencyKey: `claude-hook:${event}:${sessionId}:${eventId}`,
+        git: { worktreeId: state.worktreeId, branch: state.branch, ref: state.ref, head: state.commit },
+        privacy: { classification: captured.redactionCount > 0 || event === 'user-prompt' ? 'redacted-text' : 'metadata', redactionCount: captured.redactionCount },
+        payload: event === 'user-prompt' ? { eventId, intent: captured.intent } : { eventId },
+    });
+}
+async function maybeStartRuntime(input) {
+    const projectRoot = await resolveProjectRoot(text(input.cwd));
+    if (!await v2Enabled(projectRoot))
+        return;
+    const policy = await readJson(cognitionPolicyPath(projectRoot));
+    if (policy.allowHookStartup)
+        await within(startRuntime(projectRoot), 1_000);
+}
 async function parseInput(raw) {
     try {
         const value = JSON.parse(raw);
@@ -65,6 +115,9 @@ export async function runClaudeCodeHook(event, raw) {
     if (!input)
         return HOOK_RESPONSE;
     try {
+        if (event === 'session-start')
+            await maybeStartRuntime(input).catch(() => undefined);
+        await capture(event, input).catch(() => undefined);
         const cwd = text(input.cwd);
         const result = event === 'session-start'
             ? await contextOrient(cwd, { maxChars: 1200, noteLimit: 8 })