@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/timeline/timeline-store.js

@@ -0,0 +1,618 @@
+/**
+ * Timeline Store — third CozoDB instance at `.unerr/timeline.db`.
+ *
+ * Parallel to graph.db (Layer 2) and facts.db (Layer 9). Holds:
+ *   - turns                 : agent-turn rollups (one per closed turn)
+ *   - intents               : cross-session task groupings (ST-4)
+ *   - intent_sessions       : intent↔session many-to-many (ST-4)
+ *   - markers               : agent-emitted mark_* rows (ST-2)
+ *   - derived_signals       : mined patterns (hot files, loops, co-changes) (ST-3+)
+ *   - signal_reinforcement  : append-only reinforcement events per signal (ST-5)
+ *
+ * Schema rules (per CLAUDE.md):
+ *   - Named Datalog syntax for any relation with 4+ columns.
+ *   - All db.run() calls are async — always await.
+ *   - Edit in place, no migrations until first public release.
+ *
+ * Isolation contract: this module NEVER reads or writes graph.db or facts.db.
+ * It only opens/owns `.unerr/timeline.db`. Existing Layer 2 / Layer 9 code is
+ * untouched.
+ */
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+const TIMELINE_DB_FILENAME = "timeline.db";
+/**
+ * Open or create timeline.db at `{projectRoot}/.unerr/timeline.db`. Mirrors the
+ * factory pattern in `openFactsDb()` so the dynamic-import dance stays uniform.
+ */
+export async function openTimelineDb(projectRoot) {
+    const unerrDir = join(projectRoot, ".unerr");
+    mkdirSync(unerrDir, { recursive: true });
+    const dbPath = join(unerrDir, TIMELINE_DB_FILENAME);
+    const isNew = !existsSync(dbPath);
+    const cozoModule = await import("cozo-node");
+    const CozoDbConstructor = cozoModule.default
+        ? cozoModule.default.CozoDb
+        : cozoModule.CozoDb;
+    const db = new CozoDbConstructor("sqlite", dbPath);
+    return { db, isNew, dbPath };
+}
+async function getExistingRelations(db) {
+    const result = await db.run("::relations");
+    return new Set(result.rows.map((row) => row[0]));
+}
+/**
+ * Initialise timeline.db schema. Creates only missing relations — safe to call
+ * on fresh and existing databases. Schema is intentionally minimal here; the
+ * later sprints (ST-3/4/5) add CRUD methods on top.
+ */
+export async function initTimelineSchema(db) {
+    const existing = await getExistingRelations(db);
+    if (!existing.has("turns")) {
+        await db.run(`
+      :create turns {
+        turn_id: String
+        =>
+        session_id: String,
+        started_at: Float,
+        ended_at: Float,
+        opened_by: String,
+        closed_reason: String,
+        tool_count: Int,
+        file_count: Int,
+        edit_count: Int,
+        title: String,
+        outcome: String
+      }
+    `);
+    }
+    if (!existing.has("intents")) {
+        await db.run(`
+      :create intents {
+        intent_id: String
+        =>
+        title: String,
+        started_at: Float,
+        last_active_at: Float,
+        file_set: String,
+        file_set_hash: String,
+        status: String,
+        confidence: Float,
+        source: String
+      }
+    `);
+    }
+    if (!existing.has("intent_sessions")) {
+        await db.run(`
+      :create intent_sessions {
+        intent_id: String,
+        session_id: String
+      }
+    `);
+    }
+    if (!existing.has("markers")) {
+        await db.run(`
+      :create markers {
+        marker_id: String
+        =>
+        type: String,
+        text: String,
+        session_id: String,
+        turn_id: String,
+        ts: Float,
+        blocker_ref: String,
+        file_path: String
+      }
+    `);
+    }
+    if (!existing.has("derived_signals")) {
+        await db.run(`
+      :create derived_signals {
+        signal_id: String
+        =>
+        type: String,
+        scope: String,
+        content: String,
+        confidence: Float,
+        first_seen_at: Float,
+        last_seen_at: Float
+      }
+    `);
+    }
+    if (!existing.has("signal_reinforcement")) {
+        await db.run(`
+      :create signal_reinforcement {
+        signal_id: String,
+        ts: Float
+        =>
+        delta: Float,
+        source: String
+      }
+    `);
+    }
+    if (!existing.has("session_files")) {
+        // (session_id, file_path) — records distinct file touches per session for
+        // intent stitching (ST-4). Populated by the bootstrap when a turn closes.
+        await db.run(`
+      :create session_files {
+        session_id: String,
+        file_path: String
+      }
+    `);
+    }
+    if (!existing.has("session_agents")) {
+        // UX-1: which agent (Claude Code, Cursor, Codex, …) drove this session.
+        // Best-effort — populated when the MCP `initialize` handshake provided a
+        // clientInfo.name. Sessions without an identified client get "unknown".
+        await db.run(`
+      :create session_agents {
+        session_id: String
+        =>
+        agent_name: String,
+        first_seen: Float,
+        last_seen: Float
+      }
+    `);
+    }
+}
+// ── Store facade ─────────────────────────────────────────────────────────────
+/**
+ * Thin async wrapper around the timeline CozoDB instance. ST-1b only ships a
+ * minimal CRUD surface (turns + markers + listings). ST-3/4/5 extend this with
+ * intent, signal, and reinforcement methods.
+ */
+export class CozoTimelineStore {
+    db;
+    dbPath;
+    isNew;
+    constructor(db, dbPath, isNew) {
+        this.db = db;
+        this.dbPath = dbPath;
+        this.isNew = isNew;
+    }
+    /**
+     * Factory — opens the db and runs schema init. Use this instead of `new`.
+     */
+    static async create(projectRoot) {
+        const { db, dbPath, isNew } = await openTimelineDb(projectRoot);
+        await initTimelineSchema(db);
+        return new CozoTimelineStore(db, dbPath, isNew);
+    }
+    /** Underlying handle for tests and advanced consumers. */
+    getDb() {
+        return this.db;
+    }
+    /**
+     * Upsert a turn rollup. Called when the segmenter emits a turn-close event.
+     */
+    async upsertTurn(turn) {
+        await this.db.run(`
+      ?[turn_id, session_id, started_at, ended_at, opened_by, closed_reason, tool_count, file_count, edit_count, title, outcome] <-
+        [[$turn_id, $session_id, $started_at, $ended_at, $opened_by, $closed_reason, $tool_count, $file_count, $edit_count, $title, $outcome]]
+      :put turns {
+        turn_id
+        =>
+        session_id, started_at, ended_at, opened_by, closed_reason,
+        tool_count, file_count, edit_count, title, outcome
+      }
+    `, turn);
+    }
+    /**
+     * List turns with filters. Newest-first by `started_at`. Supports pagination
+     * (offset + limit) and substring search on `title`.
+     */
+    async listTurns(opts = {}) {
+        const limit = Math.max(1, Math.min(opts.limit ?? 50, 500));
+        const offset = Math.max(0, opts.offset ?? 0);
+        const { whereClause, params } = buildTurnFilter(opts);
+        const query = `
+      ?[turn_id, session_id, started_at, ended_at, opened_by, closed_reason, tool_count, file_count, edit_count, title, outcome] :=
+        *turns{
+          turn_id, session_id, started_at, ended_at, opened_by, closed_reason,
+          tool_count, file_count, edit_count, title, outcome
+        }${whereClause}
+      :order -started_at
+      :offset ${offset}
+      :limit ${limit}
+    `;
+        const result = await this.db.run(query, params);
+        return result.rows.map(rowToTurn);
+    }
+    /**
+     * Total number of turns matching the same filter as `listTurns`. Used for
+     * pagination footers ("page X of Y").
+     */
+    async countTurns(opts = {}) {
+        const { whereClause, params } = buildTurnFilter(opts);
+        const result = await this.db.run(`?[count(turn_id)] := *turns{turn_id, session_id, started_at, ended_at, opened_by, closed_reason, tool_count, file_count, edit_count, title, outcome}${whereClause}`, params);
+        const row = result.rows[0];
+        return row ? Number(row[0]) : 0;
+    }
+    /**
+     * List distinct sessions touched by `turns`, with aggregate stats and the
+     * agent that drove the session (when known). Powers the session + agent
+     * filters in the Timeline page.
+     */
+    async listSessions(opts = {}) {
+        const limit = Math.max(1, Math.min(opts.limit ?? 200, 1000));
+        const filters = [];
+        const params = {};
+        if (typeof opts.fromTs === "number") {
+            filters.push("started_at >= $from_ts");
+            params.from_ts = opts.fromTs;
+        }
+        if (typeof opts.toTs === "number") {
+            filters.push("started_at <= $to_ts");
+            params.to_ts = opts.toTs;
+        }
+        const whereClause = filters.length > 0 ? `, ${filters.join(", ")}` : "";
+        const result = await this.db.run(`?[session_id, min(started_at), max(ended_at), count(turn_id), sum(edit_count), sum(file_count)] :=
+        *turns{turn_id, session_id, started_at, ended_at, edit_count, file_count}${whereClause}
+       :order -max(ended_at)
+       :limit ${limit}`, params);
+        const rows = result.rows.map((r) => ({
+            session_id: r[0],
+            first_seen: r[1],
+            last_seen: r[2],
+            turn_count: r[3],
+            edit_count: r[4],
+            file_count: r[5],
+            agent_name: "unknown",
+        }));
+        // Left-join the agent name lookup in a second pass — Cozo's join syntax
+        // doesn't compose cleanly with `:order` over aggregates here.
+        const agentMap = await this.getSessionAgents(rows.map((r) => r.session_id));
+        for (const r of rows) {
+            const a = agentMap.get(r.session_id);
+            if (a)
+                r.agent_name = a;
+        }
+        return rows;
+    }
+    /**
+     * Record (or refresh) the agent name for a session. Called from the bootstrap
+     * on each turn close — first_seen is preserved across calls, last_seen
+     * advances. Best-effort; no-op when agent_name is empty.
+     */
+    async setSessionAgent(sessionId, agentName, nowMs = Date.now()) {
+        if (!agentName || agentName.length === 0)
+            return;
+        const existing = await this.db.run("?[first_seen] := *session_agents{session_id, first_seen}, session_id = $sid", { sid: sessionId });
+        const firstSeen = existing.rows.length > 0 ? existing.rows[0]?.[0] : nowMs;
+        await this.db.run(`?[session_id, agent_name, first_seen, last_seen] <-
+        [[$sid, $name, $first, $last]]
+       :put session_agents {
+         session_id => agent_name, first_seen, last_seen
+       }`, {
+            sid: sessionId,
+            name: agentName,
+            first: firstSeen,
+            last: nowMs,
+        });
+    }
+    /** Lookup the agent name for one session id. Returns null when unknown. */
+    async getSessionAgent(sessionId) {
+        const result = await this.db.run("?[agent_name] := *session_agents{session_id, agent_name}, session_id = $sid", { sid: sessionId });
+        const row = result.rows[0];
+        return row ? row[0] : null;
+    }
+    /** Batched agent lookup — used by listSessions to avoid N+1 queries. */
+    async getSessionAgents(sessionIds) {
+        const map = new Map();
+        if (sessionIds.length === 0)
+            return map;
+        // Cozo doesn't take an `IN` list directly; pull all and filter client-side.
+        const all = await this.db.run("?[session_id, agent_name] := *session_agents{session_id, agent_name}");
+        const wanted = new Set(sessionIds);
+        for (const r of all.rows) {
+            const sid = r[0];
+            if (wanted.has(sid))
+                map.set(sid, r[1]);
+        }
+        return map;
+    }
+    /**
+     * Distinct agent names with session counts. Powers the agent filter
+     * dropdown and the "agents over time" KPI.
+     */
+    async listAgents() {
+        const result = await this.db.run(`?[agent_name, count(session_id), max(last_seen)] :=
+        *session_agents{session_id, agent_name, last_seen}
+       :order -max(last_seen)`);
+        return result.rows.map((r) => ({
+            agent_name: r[0],
+            session_count: r[1],
+            last_seen: r[2],
+        }));
+    }
+    /**
+     * Bucketed activity counts for the heatmap. Returns one row per day in the
+     * `[fromTs, toTs]` range (inclusive), with zeros for empty days.
+     */
+    async getActivityBuckets(opts) {
+        const bucket = opts.bucketMs ?? 24 * 60 * 60_000;
+        const turns = await this.listTurns({
+            fromTs: opts.fromTs,
+            toTs: opts.toTs,
+            limit: 5000,
+        });
+        const map = new Map();
+        // Pre-fill the range so empty days still render.
+        for (let t = bucketStart(opts.fromTs, bucket); t <= opts.toTs; t += bucket) {
+            map.set(t, { ts: t, turns: 0, edits: 0, tools: 0 });
+        }
+        for (const turn of turns) {
+            const b = bucketStart(turn.started_at, bucket);
+            const cur = map.get(b) ?? { ts: b, turns: 0, edits: 0, tools: 0 };
+            cur.turns += 1;
+            cur.edits += turn.edit_count;
+            cur.tools += turn.tool_count;
+            map.set(b, cur);
+        }
+        return [...map.values()].sort((a, b) => a.ts - b.ts);
+    }
+    /** Insert a marker row. Used by ST-2 marker tool handlers. */
+    async insertMarker(marker) {
+        await this.db.run(`
+      ?[marker_id, type, text, session_id, turn_id, ts, blocker_ref, file_path] <-
+        [[$marker_id, $type, $text, $session_id, $turn_id, $ts, $blocker_ref, $file_path]]
+      :put markers {
+        marker_id
+        =>
+        type, text, session_id, turn_id, ts, blocker_ref, file_path
+      }
+    `, marker);
+    }
+    /**
+     * List markers, newest first. ST-3 open-threads uses this to find blockers
+     * without resolutions.
+     */
+    async listMarkers(opts = {}) {
+        const limit = opts.limit ?? 100;
+        const filters = [];
+        if (opts.sessionId)
+            filters.push("session_id = $session_id");
+        if (opts.type)
+            filters.push("type = $type");
+        const filterClause = filters.length > 0 ? `, ${filters.join(", ")}` : "";
+        const query = `
+      ?[marker_id, type, text, session_id, turn_id, ts, blocker_ref, file_path] :=
+        *markers{
+          marker_id, type, text, session_id, turn_id, ts, blocker_ref, file_path
+        }${filterClause}
+      :order -ts
+      :limit ${Math.max(1, Math.min(limit, 500))}
+    `;
+        const params = {};
+        if (opts.sessionId)
+            params.session_id = opts.sessionId;
+        if (opts.type)
+            params.type = opts.type;
+        const result = await this.db.run(query, params);
+        return result.rows.map(rowToMarker);
+    }
+    /**
+     * Record distinct file touches for a session. Called by the bootstrap on
+     * each turn-close so the intent stitcher (ST-4) has a file set to match on.
+     */
+    async recordSessionFiles(sessionId, files) {
+        const list = [...new Set([...files].filter((f) => f.length > 0))];
+        if (list.length === 0)
+            return;
+        // CozoDB :put against a many-row relation works one row at a time.
+        for (const fp of list) {
+            await this.db.run(`?[session_id, file_path] <- [[$session_id, $file_path]]
+         :put session_files { session_id, file_path }`, { session_id: sessionId, file_path: fp });
+        }
+    }
+    async getSessionFiles(sessionId) {
+        const result = await this.db.run("?[file_path] := *session_files{session_id: $session_id, file_path}", { session_id: sessionId });
+        return result.rows.map((r) => r[0]);
+    }
+    async upsertIntent(intent) {
+        await this.db.run(`?[intent_id, title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source] <-
+        [[$intent_id, $title, $started_at, $last_active_at, $file_set, $file_set_hash, $status, $confidence, $source]]
+       :put intents {
+         intent_id
+         => title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source
+       }`, intent);
+    }
+    async listIntents(opts = {}) {
+        const limit = Math.max(1, Math.min(opts.limit ?? 100, 500));
+        const filter = opts.status ? ", status = $status" : "";
+        const query = `?[intent_id, title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source] :=
+        *intents{intent_id, title, started_at, last_active_at, file_set, file_set_hash, status, confidence, source}${filter}
+      :order -last_active_at
+      :limit ${limit}`;
+        const params = {};
+        if (opts.status)
+            params.status = opts.status;
+        const result = await this.db.run(query, params);
+        return result.rows.map((r) => ({
+            intent_id: r[0],
+            title: r[1],
+            started_at: r[2],
+            last_active_at: r[3],
+            file_set: r[4],
+            file_set_hash: r[5],
+            status: r[6],
+            confidence: r[7],
+            source: r[8],
+        }));
+    }
+    async attachSession(intentId, sessionId) {
+        await this.db.run(`?[intent_id, session_id] <- [[$intent_id, $session_id]]
+       :put intent_sessions { intent_id, session_id }`, { intent_id: intentId, session_id: sessionId });
+    }
+    async listIntentSessions(intentId) {
+        const result = await this.db.run("?[session_id] := *intent_sessions{intent_id: $intent_id, session_id}", { intent_id: intentId });
+        return result.rows.map((r) => r[0]);
+    }
+    /**
+     * Reverse lookup: find the intent (if any) attached to a session.
+     */
+    async findIntentForSession(sessionId) {
+        const result = await this.db.run("?[intent_id] := *intent_sessions{intent_id, session_id: $session_id}", { session_id: sessionId });
+        const row = result.rows[0];
+        return row ? row[0] : null;
+    }
+    // ── ST-5: Derived signals + reinforcement ─────────────────────────────
+    async upsertSignal(signal) {
+        await this.db.run(`?[signal_id, type, scope, content, confidence, first_seen_at, last_seen_at] <-
+        [[$signal_id, $type, $scope, $content, $confidence, $first_seen_at, $last_seen_at]]
+       :put derived_signals {
+         signal_id => type, scope, content, confidence, first_seen_at, last_seen_at
+       }`, signal);
+    }
+    async getSignal(signalId) {
+        const result = await this.db.run(`?[signal_id, type, scope, content, confidence, first_seen_at, last_seen_at] :=
+         *derived_signals{signal_id, type, scope, content, confidence, first_seen_at, last_seen_at},
+         signal_id = $signal_id`, { signal_id: signalId });
+        const row = result.rows[0];
+        if (!row)
+            return null;
+        return rowToSignal(row);
+    }
+    async listSignals(opts = {}) {
+        const limit = Math.max(1, Math.min(opts.limit ?? 50, 500));
+        const filters = [];
+        if (opts.type)
+            filters.push("type = $type");
+        if (typeof opts.minConfidence === "number")
+            filters.push("confidence >= $min_confidence");
+        const filterClause = filters.length > 0 ? `, ${filters.join(", ")}` : "";
+        const query = `?[signal_id, type, scope, content, confidence, first_seen_at, last_seen_at] :=
+        *derived_signals{signal_id, type, scope, content, confidence, first_seen_at, last_seen_at}${filterClause}
+      :order -last_seen_at
+      :limit ${limit}`;
+        const params = {};
+        if (opts.type)
+            params.type = opts.type;
+        if (typeof opts.minConfidence === "number")
+            params.min_confidence = opts.minConfidence;
+        const result = await this.db.run(query, params);
+        return result.rows.map(rowToSignal);
+    }
+    async appendReinforcement(signalId, ts, delta, source) {
+        await this.db.run(`?[signal_id, ts, delta, source] <-
+        [[$signal_id, $ts, $delta, $source]]
+       :put signal_reinforcement { signal_id, ts => delta, source }`, {
+            signal_id: signalId,
+            ts,
+            delta,
+            source,
+        });
+    }
+    async getReinforcementHistory(signalId, limit = 10) {
+        const result = await this.db.run(`?[signal_id, ts, delta, source] :=
+        *signal_reinforcement{signal_id, ts, delta, source},
+        signal_id = $signal_id
+      :order -ts
+      :limit ${Math.max(1, Math.min(limit, 100))}`, { signal_id: signalId });
+        return result.rows.map((r) => ({
+            signal_id: r[0],
+            ts: r[1],
+            delta: r[2],
+            source: r[3],
+        }));
+    }
+    /**
+     * Delete signals last seen before `cutoffMs`. Returns the number removed.
+     * Cascades: matching reinforcement history rows are also removed.
+     */
+    async deleteSignalsBefore(cutoffMs) {
+        const stale = await this.db.run(`?[signal_id] := *derived_signals{signal_id, last_seen_at},
+        last_seen_at < $cutoff`, { cutoff: cutoffMs });
+        const ids = stale.rows.map((r) => r[0]);
+        for (const id of ids) {
+            await this.db.run(`?[signal_id] := *derived_signals{signal_id}, signal_id = $signal_id
+         :rm derived_signals { signal_id }`, { signal_id: id });
+            await this.db.run(`?[signal_id, ts] := *signal_reinforcement{signal_id, ts}, signal_id = $signal_id
+         :rm signal_reinforcement { signal_id, ts }`, { signal_id: id });
+        }
+        return ids.length;
+    }
+    /** Cleanly close the underlying CozoDB handle. */
+    close() {
+        this.db.close?.();
+    }
+}
+function rowToSignal(row) {
+    return {
+        signal_id: row[0],
+        type: row[1],
+        scope: row[2],
+        content: row[3],
+        confidence: row[4],
+        first_seen_at: row[5],
+        last_seen_at: row[6],
+    };
+}
+function rowToTurn(row) {
+    return {
+        turn_id: row[0],
+        session_id: row[1],
+        started_at: row[2],
+        ended_at: row[3],
+        opened_by: row[4],
+        closed_reason: row[5],
+        tool_count: row[6],
+        file_count: row[7],
+        edit_count: row[8],
+        title: row[9],
+        outcome: row[10],
+    };
+}
+function rowToMarker(row) {
+    return {
+        marker_id: row[0],
+        type: row[1],
+        text: row[2],
+        session_id: row[3],
+        turn_id: row[4],
+        ts: row[5],
+        blocker_ref: row[6],
+        file_path: row[7],
+    };
+}
+/**
+ * Build the Datalog WHERE-clause fragment + params for the turn-filter family
+ * (listTurns, countTurns). Centralised so listTurns and countTurns share the
+ * same semantics and can't drift.
+ */
+function buildTurnFilter(opts) {
+    const filters = [];
+    const params = {};
+    if (opts.sessionId) {
+        filters.push("session_id = $session_id");
+        params.session_id = opts.sessionId;
+    }
+    if (typeof opts.fromTs === "number") {
+        filters.push("started_at >= $from_ts");
+        params.from_ts = opts.fromTs;
+    }
+    if (typeof opts.toTs === "number") {
+        filters.push("started_at <= $to_ts");
+        params.to_ts = opts.toTs;
+    }
+    if (opts.query && opts.query.trim().length > 0) {
+        // Case-insensitive substring search via Cozo's `regex_matches`. The pattern
+        // is regex-escaped so `?` / `.` / `(` / `[` etc. in the user input don't
+        // accidentally turn into wildcards.
+        filters.push("regex_matches(title, $q_re)");
+        params.q_re = `(?i).*${escapeRegex(opts.query.trim())}.*`;
+    }
+    return {
+        whereClause: filters.length > 0 ? `, ${filters.join(", ")}` : "",
+        params,
+    };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Floor a timestamp to the start of its bucket (e.g. UTC midnight for 24h). */
+function bucketStart(ts, bucketMs) {
+    if (!Number.isFinite(ts) || bucketMs <= 0)
+        return ts;
+    return Math.floor(ts / bucketMs) * bucketMs;
+}

package/dist/tools/coding/bash.js

@@ -0,0 +1,49 @@
+/**
+ * Bash Tool — execute shell commands.
+ * Requires user permission for non-trivial commands. Streams output.
+ */
+import { exec } from "../../utils/exec.js";
+export const bashTool = {
+    name: "bash",
+    description: "Execute a bash command in the project directory. Returns stdout and stderr. " +
+        "Use this for running tests, git commands, build scripts, and other shell operations. " +
+        "Commands time out after 2 minutes.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "The bash command to execute",
+            },
+            timeout: {
+                type: "number",
+                description: "Timeout in milliseconds. Default: 120000 (2 minutes)",
+            },
+        },
+        required: ["command"],
+    },
+    isReadOnly: false,
+    requiresPermission: true,
+    async execute(args, ctx) {
+        const command = args.command;
+        const timeout = Math.min(args.timeout ?? 120_000, 600_000);
+        const result = await exec("bash", ["-c", command], {
+            cwd: ctx.cwd,
+            timeout,
+        });
+        if (result.exitCode === 0) {
+            return { content: result.stdout || "(no output)" };
+        }
+        const parts = [];
+        if (result.stdout)
+            parts.push(result.stdout);
+        if (result.stderr)
+            parts.push(result.stderr);
+        if (parts.length === 0)
+            parts.push("Command failed");
+        return {
+            content: `Exit code: ${result.exitCode}\n${parts.join("\n")}`,
+            isError: true,
+        };
+    },
+};