sidecar-cli 0.1.5-beta.1 → 0.1.5-beta.2

package/dist/runs/capture.js

@@ -0,0 +1,429 @@
+import { spawn } from 'node:child_process';
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export const VALIDATION_KINDS = ['typecheck', 'lint', 'test', 'build', 'custom'];
+// Per-kind default timeouts. `custom` keeps the historical 5-minute budget; tests/builds
+// get a longer default because they're the common cause of the 5m ceiling biting.
+export const DEFAULT_VALIDATION_TIMEOUT_MS = {
+    typecheck: 3 * 60 * 1000,
+    lint: 3 * 60 * 1000,
+    test: 10 * 60 * 1000,
+    build: 10 * 60 * 1000,
+    custom: 5 * 60 * 1000,
+};
+const KILL_GRACE_MS = 5 * 1000;
+const SNIPPET_LIMIT = 1000;
+export function isValidationKind(value) {
+    return typeof value === 'string' && VALIDATION_KINDS.includes(value);
+}
+export function normalizeValidationStep(entry) {
+    if (typeof entry === 'string') {
+        const raw = entry.trim();
+        if (raw.length === 0)
+            return null;
+        // Support "kind:command" shorthand — but only when the prefix before the first
+        // colon is a known kind. Anything else (URLs, paths, env vars, bash substitutions)
+        // falls through as a plain custom command.
+        // Also accepts "kind@<duration>:command" where <duration> is "30s", "2m", or "1500ms"
+        // to override the per-kind default timeout.
+        const colonIdx = raw.indexOf(':');
+        if (colonIdx > 0) {
+            const prefix = raw.slice(0, colonIdx).trim();
+            const rest = raw.slice(colonIdx + 1).trim();
+            const atIdx = prefix.indexOf('@');
+            if (atIdx > 0) {
+                const kindPart = prefix.slice(0, atIdx).trim();
+                const durationPart = prefix.slice(atIdx + 1).trim();
+                if (isValidationKind(kindPart) && rest.length > 0) {
+                    const parsed = parseDurationToMs(durationPart);
+                    const step = { kind: kindPart, command: rest };
+                    if (parsed != null)
+                        step.timeout_ms = parsed;
+                    return step;
+                }
+            }
+            if (isValidationKind(prefix) && rest.length > 0) {
+                return { kind: prefix, command: rest };
+            }
+        }
+        return { kind: 'custom', command: raw };
+    }
+    if (!entry || typeof entry !== 'object')
+        return null;
+    const command = typeof entry.command === 'string' ? entry.command.trim() : '';
+    if (command.length === 0)
+        return null;
+    const kind = isValidationKind(entry.kind) ? entry.kind : 'custom';
+    const step = { kind, command };
+    if (typeof entry.name === 'string' && entry.name.trim().length > 0)
+        step.name = entry.name.trim();
+    const rawTimeout = typeof entry.timeout_ms === 'number'
+        ? entry.timeout_ms
+        : typeof entry.timeoutMs === 'number'
+            ? entry.timeoutMs
+            : undefined;
+    if (typeof rawTimeout === 'number' && Number.isFinite(rawTimeout) && rawTimeout > 0) {
+        step.timeout_ms = Math.floor(rawTimeout);
+    }
+    return step;
+}
+export function resolveValidationTimeoutMs(step) {
+    if (typeof step.timeout_ms === 'number' && step.timeout_ms > 0)
+        return step.timeout_ms;
+    return DEFAULT_VALIDATION_TIMEOUT_MS[step.kind];
+}
+// Parse "30s", "2m", "1500ms" → milliseconds. Returns null on unknown format.
+export function parseDurationToMs(raw) {
+    const match = /^(\d+)(ms|s|m)$/i.exec(raw.trim());
+    if (!match)
+        return null;
+    const value = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(value) || value <= 0)
+        return null;
+    const unit = match[2].toLowerCase();
+    if (unit === 'ms')
+        return value;
+    if (unit === 's')
+        return value * 1000;
+    if (unit === 'm')
+        return value * 60 * 1000;
+    return null;
+}
+export async function captureHeadSha(cwd) {
+    try {
+        const { stdout, exitCode } = await runGit(cwd, ['rev-parse', 'HEAD']);
+        if (exitCode !== 0)
+            return null;
+        const trimmed = stdout.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function captureWorkingTreeSnapshot(cwd) {
+    let trackedRef = null;
+    try {
+        const stash = await runGit(cwd, ['stash', 'create']);
+        const candidate = stash.exitCode === 0 ? stash.stdout.trim() : '';
+        if (candidate.length > 0) {
+            trackedRef = candidate;
+        }
+        else {
+            const head = await runGit(cwd, ['rev-parse', 'HEAD']);
+            if (head.exitCode === 0) {
+                const h = head.stdout.trim();
+                trackedRef = h.length > 0 ? h : null;
+            }
+        }
+    }
+    catch {
+        trackedRef = null;
+    }
+    const untracked = await listUntracked(cwd);
+    return { trackedRef, untracked };
+}
+export async function captureFilesChangedSince(cwd, snapshot) {
+    const files = new Set();
+    if (snapshot.trackedRef) {
+        try {
+            const { stdout, exitCode } = await runGit(cwd, ['diff', '--name-only', snapshot.trackedRef]);
+            if (exitCode === 0) {
+                for (const line of stdout.split('\n')) {
+                    const trimmed = line.trim();
+                    if (trimmed.length > 0)
+                        files.add(trimmed);
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const untrackedNow = await listUntracked(cwd);
+    const before = new Set(snapshot.untracked);
+    for (const f of untrackedNow) {
+        if (!before.has(f))
+            files.add(f);
+    }
+    return dedupeSort(Array.from(files));
+}
+async function listUntracked(cwd) {
+    try {
+        const { stdout, exitCode } = await runGit(cwd, ['ls-files', '--others', '--exclude-standard']);
+        if (exitCode !== 0)
+            return [];
+        return stdout
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+export async function captureChangedFiles(cwd, sinceRef) {
+    try {
+        if (sinceRef && sinceRef.length > 0) {
+            const { stdout, exitCode } = await runGit(cwd, ['diff', '--name-only', sinceRef]);
+            if (exitCode !== 0)
+                return [];
+            return dedupeSort(stdout
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0));
+        }
+        const { stdout, exitCode } = await runGit(cwd, ['status', '--porcelain']);
+        if (exitCode !== 0)
+            return [];
+        const files = [];
+        for (const rawLine of stdout.split('\n')) {
+            const line = rawLine.replace(/\r$/, '');
+            if (line.length === 0)
+                continue;
+            const payload = line.length > 3 ? line.slice(3) : '';
+            if (payload.length === 0)
+                continue;
+            const arrowIdx = payload.indexOf(' -> ');
+            const path = arrowIdx >= 0 ? payload.slice(arrowIdx + 4) : payload;
+            const unquoted = unquoteGitPath(path.trim());
+            if (unquoted.length > 0)
+                files.push(unquoted);
+        }
+        return dedupeSort(files);
+    }
+    catch {
+        return [];
+    }
+}
+export async function runValidationCommands(cwd, steps, logPath) {
+    const results = [];
+    if (logPath)
+        ensureLogDir(logPath);
+    for (const step of steps) {
+        const result = await runOneValidation(cwd, step, logPath);
+        results.push(result);
+    }
+    return results;
+}
+export function formatValidationResultsForRecord(results) {
+    if (results.length === 0)
+        return [];
+    return results.map((r) => {
+        const label = r.name ? `${r.kind}:${r.name}` : r.kind;
+        if (r.timedOut)
+            return `${label} (${r.command}): timed out (${r.durationMs}ms)`;
+        return r.ok
+            ? `${label} (${r.command}): ok (${r.durationMs}ms)`
+            : `${label} (${r.command}): failed (exit ${r.exitCode}, ${r.durationMs}ms)`;
+    });
+}
+async function runOneValidation(cwd, step, logPath) {
+    const start = Date.now();
+    const timeoutMs = resolveValidationTimeoutMs(step);
+    const { kind, command, name } = step;
+    try {
+        if (logPath) {
+            const label = name ? `${kind}:${name}` : kind;
+            appendFileSync(logPath, `\n\n--- validation [${label}]: ${command} ---\n`);
+        }
+        return await new Promise((resolve) => {
+            let child;
+            try {
+                child = spawn(command, {
+                    cwd,
+                    shell: true,
+                    env: { ...process.env },
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+            }
+            catch (err) {
+                resolve({
+                    kind,
+                    command,
+                    ...(name ? { name } : {}),
+                    exitCode: -1,
+                    ok: false,
+                    timedOut: false,
+                    durationMs: Date.now() - start,
+                    timeoutMs,
+                    outputSnippet: errorMessage(err),
+                });
+                return;
+            }
+            let buffer = '';
+            let timedOut = false;
+            let killTimer = null;
+            let settled = false;
+            const appendToBuffer = (chunk) => {
+                buffer += chunk.toString('utf8');
+                if (buffer.length > SNIPPET_LIMIT * 4) {
+                    buffer = buffer.slice(buffer.length - SNIPPET_LIMIT * 4);
+                }
+            };
+            const teeToLog = (chunk) => {
+                if (!logPath)
+                    return;
+                try {
+                    appendFileSync(logPath, chunk);
+                }
+                catch {
+                    // ignore log write errors
+                }
+            };
+            child.stdout?.on('data', (chunk) => {
+                appendToBuffer(chunk);
+                teeToLog(chunk);
+            });
+            child.stderr?.on('data', (chunk) => {
+                appendToBuffer(chunk);
+                teeToLog(chunk);
+            });
+            const timeoutTimer = setTimeout(() => {
+                timedOut = true;
+                try {
+                    child.kill('SIGTERM');
+                }
+                catch {
+                    // ignore
+                }
+                killTimer = setTimeout(() => {
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        // ignore
+                    }
+                }, KILL_GRACE_MS);
+            }, timeoutMs);
+            const finalize = (exitCode) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutTimer);
+                if (killTimer)
+                    clearTimeout(killTimer);
+                const durationMs = Date.now() - start;
+                let snippet = buffer.length > SNIPPET_LIMIT ? buffer.slice(buffer.length - SNIPPET_LIMIT) : buffer;
+                snippet = snippet.trim();
+                if (timedOut) {
+                    const marker = `[timed out after ${Math.round(timeoutMs / 1000)}s]`;
+                    snippet = snippet.length > 0 ? `${snippet}\n${marker}` : marker;
+                    resolve({
+                        kind,
+                        command,
+                        ...(name ? { name } : {}),
+                        exitCode: 124,
+                        ok: false,
+                        timedOut: true,
+                        durationMs,
+                        timeoutMs,
+                        outputSnippet: snippet,
+                    });
+                    return;
+                }
+                resolve({
+                    kind,
+                    command,
+                    ...(name ? { name } : {}),
+                    exitCode,
+                    ok: exitCode === 0,
+                    timedOut: false,
+                    durationMs,
+                    timeoutMs,
+                    outputSnippet: snippet,
+                });
+            };
+            child.on('error', (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeoutTimer);
+                if (killTimer)
+                    clearTimeout(killTimer);
+                resolve({
+                    kind,
+                    command,
+                    ...(name ? { name } : {}),
+                    exitCode: -1,
+                    ok: false,
+                    timedOut: false,
+                    durationMs: Date.now() - start,
+                    timeoutMs,
+                    outputSnippet: errorMessage(err),
+                });
+            });
+            child.on('close', (code, signal) => {
+                const exitCode = typeof code === 'number' ? code : signal ? 128 : -1;
+                finalize(exitCode);
+            });
+        });
+    }
+    catch (err) {
+        return {
+            kind,
+            command,
+            ...(name ? { name } : {}),
+            exitCode: -1,
+            ok: false,
+            timedOut: false,
+            durationMs: Date.now() - start,
+            timeoutMs,
+            outputSnippet: errorMessage(err),
+        };
+    }
+}
+function runGit(cwd, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn('git', args, {
+                cwd,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: { ...process.env },
+            });
+        }
+        catch (err) {
+            resolve({ stdout: '', stderr: errorMessage(err), exitCode: -1 });
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString('utf8');
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString('utf8');
+        });
+        child.on('error', (err) => {
+            resolve({ stdout, stderr: stderr + errorMessage(err), exitCode: -1 });
+        });
+        child.on('close', (code, signal) => {
+            const exitCode = typeof code === 'number' ? code : signal ? 128 : -1;
+            resolve({ stdout, stderr, exitCode });
+        });
+    });
+}
+function dedupeSort(items) {
+    return Array.from(new Set(items)).sort((a, b) => a.localeCompare(b));
+}
+function unquoteGitPath(path) {
+    if (path.length >= 2 && path.startsWith('"') && path.endsWith('"')) {
+        const inner = path.slice(1, -1);
+        return inner.replace(/\\(.)/g, '$1');
+    }
+    return path;
+}
+function ensureLogDir(logPath) {
+    try {
+        mkdirSync(dirname(logPath), { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+}
+function errorMessage(err) {
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}

package/dist/runs/run-record.js

@@ -5,6 +5,22 @@ export const runIdSchema = z.string().regex(/^R-\d{3,}$/, 'Run id must look like
 export const runStatusSchema = z.enum(['queued', 'preparing', 'running', 'review', 'blocked', 'completed', 'failed']);
 export const runnerTypeSchema = z.enum(['codex', 'claude']);
 export const runReviewStateSchema = z.enum(['pending', 'approved', 'needs_changes', 'blocked', 'merged']);
+export const runValidationKindSchema = z.enum(['typecheck', 'lint', 'test', 'build', 'custom']);
+export const runValidationEntrySchema = z
+    .object({
+    kind: runValidationKindSchema,
+    command: z.string(),
+    name: z.string().optional(),
+    exit_code: z.number().int(),
+    ok: z.boolean(),
+    timed_out: z.boolean().default(false),
+    duration_ms: z.number().int().nonnegative().default(0),
+    // Resolved timeout for this step (defaulting by kind when not set explicitly).
+    // Persisted so the UI can show "ran in 12s / limit 60s" without re-deriving.
+    timeout_ms: z.number().int().nonnegative().default(0),
+    output_snippet: z.string().default(''),
+})
+    .strict();
 export const runRecordSchema = z
     .object({
     version: z.string().default(RUN_RECORD_VERSION),
@@ -22,6 +38,7 @@ export const runRecordSchema = z
     changed_files: z.array(z.string()).default([]),
     commands_run: z.array(z.string()).default([]),
     validation_results: z.array(z.string()).default([]),
+    validation: z.array(runValidationEntrySchema).default([]),
     blockers: z.array(z.string()).default([]),
     follow_ups: z.array(z.string()).default([]),
     review_state: runReviewStateSchema.default('pending'),
@@ -32,6 +49,13 @@ export const runRecordSchema = z
     prompt_tokens_estimated_after: z.number().int().nonnegative().default(0),
     prompt_budget_target: z.number().int().nonnegative().default(0),
     prompt_trimmed_sections: z.array(z.string()).default([]),
+    parent_run_id: runIdSchema.nullable().default(null),
+    replay_reason: z.string().default(''),
+    // Dual-runner pipeline: siblings share a `pipeline_id` and carry 1-based
+    // step + total so downstream consumers can reconstruct the chain.
+    pipeline_id: z.string().nullable().default(null),
+    pipeline_step: z.number().int().positive().nullable().default(null),
+    pipeline_total: z.number().int().positive().nullable().default(null),
 })
     .strict();
 export const runRecordCreateInputSchema = runRecordSchema
@@ -47,6 +71,7 @@ export const runRecordCreateInputSchema = runRecordSchema
     changed_files: true,
     commands_run: true,
     validation_results: true,
+    validation: true,
     blockers: true,
     follow_ups: true,
     review_state: true,
@@ -57,6 +82,11 @@ export const runRecordCreateInputSchema = runRecordSchema
     prompt_tokens_estimated_after: true,
     prompt_budget_target: true,
     prompt_trimmed_sections: true,
+    parent_run_id: true,
+    replay_reason: true,
+    pipeline_id: true,
+    pipeline_step: true,
+    pipeline_total: true,
 });
 export const runRecordUpdateInputSchema = z
     .object({
@@ -69,6 +99,7 @@ export const runRecordUpdateInputSchema = z
     changed_files: z.array(z.string()).optional(),
     commands_run: z.array(z.string()).optional(),
     validation_results: z.array(z.string()).optional(),
+    validation: z.array(runValidationEntrySchema).optional(),
     blockers: z.array(z.string()).optional(),
     follow_ups: z.array(z.string()).optional(),
     review_state: runReviewStateSchema.optional(),
@@ -79,6 +110,11 @@ export const runRecordUpdateInputSchema = z
     prompt_tokens_estimated_after: z.number().int().nonnegative().optional(),
     prompt_budget_target: z.number().int().nonnegative().optional(),
     prompt_trimmed_sections: z.array(z.string()).optional(),
+    parent_run_id: runIdSchema.nullable().optional(),
+    replay_reason: z.string().optional(),
+    pipeline_id: z.string().nullable().optional(),
+    pipeline_step: z.number().int().positive().nullable().optional(),
+    pipeline_total: z.number().int().positive().nullable().optional(),
 })
     .strict();
 export function createRunRecord(runId, input) {
@@ -98,6 +134,7 @@ export function createRunRecord(runId, input) {
         changed_files: input.changed_files ?? [],
         commands_run: input.commands_run ?? [],
         validation_results: input.validation_results ?? [],
+        validation: input.validation ?? [],
         blockers: input.blockers ?? [],
         follow_ups: input.follow_ups ?? [],
         review_state: input.review_state ?? 'pending',
@@ -108,6 +145,11 @@ export function createRunRecord(runId, input) {
         prompt_tokens_estimated_after: input.prompt_tokens_estimated_after ?? 0,
         prompt_budget_target: input.prompt_budget_target ?? 0,
         prompt_trimmed_sections: input.prompt_trimmed_sections ?? [],
+        parent_run_id: input.parent_run_id ?? null,
+        replay_reason: input.replay_reason ?? '',
+        pipeline_id: input.pipeline_id ?? null,
+        pipeline_step: input.pipeline_step ?? null,
+        pipeline_total: input.pipeline_total ?? null,
     };
     return runRecordSchema.parse(normalized);
 }

package/dist/runs/run-repository.js

@@ -51,6 +51,7 @@ export class RunRecordRepository {
             changed_files: parsedPatch.changed_files ?? existing.changed_files,
             commands_run: parsedPatch.commands_run ?? existing.commands_run,
             validation_results: parsedPatch.validation_results ?? existing.validation_results,
+            validation: parsedPatch.validation ?? existing.validation,
             blockers: parsedPatch.blockers ?? existing.blockers,
             follow_ups: parsedPatch.follow_ups ?? existing.follow_ups,
             prompt_trimmed_sections: parsedPatch.prompt_trimmed_sections ?? existing.prompt_trimmed_sections,

package/dist/services/hook-service.js

@@ -0,0 +1,130 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { startSession, endSession, currentSession } from './session-service.js';
+import { addWorklog, addNote, getActiveSessionId } from './event-service.js';
+import { addArtifact } from './artifact-service.js';
+export const HOOK_EVENTS = ['session-start', 'session-end', 'file-edit', 'user-prompt'];
+export const hookEventSchema = z.enum(HOOK_EVENTS);
+// Claude Code hook payload — all fields optional since the hook can be triggered by different
+// events and other sources (Codex) may supply a subset.
+export const hookPayloadSchema = z
+    .object({
+    session_id: z.string().optional(),
+    transcript_path: z.string().optional(),
+    cwd: z.string().optional(),
+    hook_event_name: z.string().optional(),
+    tool_name: z.string().optional(),
+    tool_input: z.record(z.string(), z.unknown()).optional(),
+    tool_response: z.record(z.string(), z.unknown()).optional(),
+    prompt: z.string().optional(),
+    message: z.string().optional(),
+})
+    .passthrough();
+const EDIT_TOOL_NAMES = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+const MAX_PROMPT_LEN = 200;
+function deriveActorName(payload, override) {
+    if (override && override.trim())
+        return override.trim();
+    const sid = typeof payload.session_id === 'string' ? payload.session_id.slice(0, 8) : '';
+    return sid ? `claude-code:${sid}` : 'claude-code';
+}
+function canonical(p) {
+    try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    }
+}
+function toRelativePath(projectRoot, filePath) {
+    try {
+        const rel = path.relative(canonical(projectRoot), canonical(filePath));
+        if (rel && !rel.startsWith('..'))
+            return rel.replaceAll('\\', '/');
+    }
+    catch {
+        // fall through
+    }
+    return filePath;
+}
+// Lazy-open an agent session when an ambient event fires with no active one.
+// Keeps ambient capture working even if SessionStart never ran (e.g. hooks installed
+// mid-session). Returns the resolved session id (existing or newly created).
+function ensureSession(db, projectId, actorName) {
+    const existing = getActiveSessionId(db, projectId);
+    if (existing)
+        return existing;
+    const started = startSession(db, { projectId, actor: 'agent', name: actorName });
+    if (!started.ok)
+        return null;
+    return started.sessionId;
+}
+export function handleHookEvent(input) {
+    const { db, projectId, projectRoot, event, payload } = input;
+    const actorName = deriveActorName(payload, input.actorName);
+    if (event === 'session-start') {
+        const active = currentSession(db, projectId);
+        if (active) {
+            return { ok: true, event, action: 'noop', detail: 'session already active', session_id: active.id };
+        }
+        const started = startSession(db, { projectId, actor: 'agent', name: actorName });
+        if (!started.ok) {
+            return { ok: true, event, action: 'noop', detail: started.reason };
+        }
+        return { ok: true, event, action: 'started', session_id: started.sessionId };
+    }
+    if (event === 'session-end') {
+        const active = currentSession(db, projectId);
+        if (!active) {
+            return { ok: true, event, action: 'noop', detail: 'no active session' };
+        }
+        const summary = typeof payload.message === 'string' && payload.message.trim()
+            ? payload.message.trim()
+            : `Hook: session ended (${actorName})`;
+        const ended = endSession(db, { projectId, summary });
+        if (!ended.ok) {
+            return { ok: true, event, action: 'noop', detail: ended.reason };
+        }
+        return { ok: true, event, action: 'ended', session_id: ended.sessionId };
+    }
+    if (event === 'file-edit') {
+        const toolName = typeof payload.tool_name === 'string' ? payload.tool_name : '';
+        if (toolName && !EDIT_TOOL_NAMES.has(toolName)) {
+            return { ok: true, event, action: 'noop', detail: `ignored tool: ${toolName}` };
+        }
+        const toolInput = (payload.tool_input ?? {});
+        const rawPath = typeof toolInput.file_path === 'string' ? toolInput.file_path : '';
+        if (!rawPath) {
+            return { ok: true, event, action: 'noop', detail: 'no file_path in tool_input' };
+        }
+        const relPath = toRelativePath(projectRoot, rawPath);
+        const sessionId = ensureSession(db, projectId, actorName);
+        const { eventId } = addWorklog(db, {
+            projectId,
+            done: `Edited ${relPath} via ${toolName || 'Claude Code'}`,
+            files: relPath,
+            by: 'agent',
+            sessionId,
+        });
+        addArtifact(db, { projectId, path: relPath, kind: 'file' });
+        return { ok: true, event, action: 'recorded', session_id: sessionId, event_id: eventId };
+    }
+    if (event === 'user-prompt') {
+        const prompt = typeof payload.prompt === 'string' ? payload.prompt.trim() : '';
+        if (!prompt) {
+            return { ok: true, event, action: 'noop', detail: 'empty prompt' };
+        }
+        const truncated = prompt.length > MAX_PROMPT_LEN ? `${prompt.slice(0, MAX_PROMPT_LEN)}…` : prompt;
+        const sessionId = ensureSession(db, projectId, actorName);
+        const eventId = addNote(db, {
+            projectId,
+            title: 'User prompt',
+            text: truncated,
+            by: 'agent',
+            sessionId,
+        });
+        return { ok: true, event, action: 'recorded', session_id: sessionId, event_id: eventId };
+    }
+    return { ok: true, event, action: 'noop', detail: 'unknown event' };
+}