specrails-desktop 2.0.0

package/server/dist/smash-runner.js

@@ -0,0 +1,663 @@
+"use strict";
+/**
+ * SPECs SMASH — Runner
+ *
+ * Standalone orchestrator for a single SMASH turn. Spawns a fresh `claude`
+ * with the byte-stable SMASH system prompt, parses the JSON response, then
+ * atomically flips the parent ticket to `is_epic` and inserts N child
+ * tickets inside a single `mutateStore` callback.
+ *
+ * See openspec/changes/add-specs-smash.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSmashEligibility = checkSmashEligibility;
+exports.prepareSmashSpawn = prepareSmashSpawn;
+exports.readSmashChildOutput = readSmashChildOutput;
+exports.composeChildDescription = composeChildDescription;
+exports.applySmashToStore = applySmashToStore;
+exports.applySmashUndo = applySmashUndo;
+exports.applyDeleteEpicChildren = applyDeleteEpicChildren;
+exports.runSmash = runSmash;
+exports.runSmashUndo = runSmashUndo;
+const node_crypto_1 = require("node:crypto");
+const node_readline_1 = require("node:readline");
+const cli_prompt_1 = require("./util/cli-prompt");
+const explore_smash_1 = require("./explore-smash");
+const explore_cwd_manager_1 = require("./explore-cwd-manager");
+const ai_invocations_1 = require("./ai-invocations");
+const result_event_1 = require("./result-event");
+const ticket_store_1 = require("./ticket-store");
+const ticket_store_2 = require("./ticket-store");
+const SMASH_TIMEOUT_MS_SIMPLE = 60_000;
+const SMASH_TIMEOUT_MS_FULL = 900_000; // 15 min — super-spec mode, no rush
+const SMASH_MAX_TURNS_SIMPLE = 1;
+const SMASH_MAX_TURNS_FULL = 30; // plenty of room for codebase exploration
+// ─── Pre-flight gating ───────────────────────────────────────────────────────
+const CONTRACT_LAYER_MARKER = '## Contract Layer';
+/**
+ * Check whether the ticket is eligible to be SMASHed. Pure function for ease
+ * of testing — does not mutate state, does not depend on env.
+ */
+function checkSmashEligibility(store, ticketId) {
+    const ticket = store.tickets[String(ticketId)];
+    if (!ticket)
+        return { ok: false, reason: 'ticket-not-found' };
+    if (ticket.status === 'draft')
+        return { ok: false, reason: 'is-draft' };
+    if (ticket.parent_epic_id !== null)
+        return { ok: false, reason: 'is-child' };
+    if (!ticket.description.includes(CONTRACT_LAYER_MARKER)) {
+        return { ok: false, reason: 'no-contract-layer' };
+    }
+    // Already-épica with children → must delete first.
+    let childCount = 0;
+    for (const id of Object.keys(store.tickets)) {
+        if (store.tickets[id].parent_epic_id === ticketId)
+            childCount += 1;
+    }
+    if (ticket.is_epic && childCount > 0)
+        return { ok: false, reason: 'has-children' };
+    return { ok: true, context: { ticket, childCount } };
+}
+// ─── Spawn helpers ───────────────────────────────────────────────────────────
+function buildSmashArgs(model, systemPrompt, userPrompt, mode) {
+    // Simple: deny all tools, single turn — fast, no codebase access.
+    // Full: allow Read/Grep/Glob (read-only), multi-turn — slower, grounded.
+    const disallowed = mode === 'full' ? 'Bash,Edit,Write,NotebookEdit' : 'Read,Grep,Glob,Bash';
+    const maxTurns = mode === 'full' ? SMASH_MAX_TURNS_FULL : SMASH_MAX_TURNS_SIMPLE;
+    return [
+        '--model', model,
+        '--dangerously-skip-permissions',
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--system-prompt', systemPrompt,
+        '--disallowedTools', disallowed,
+        '--max-turns', String(maxTurns),
+        '-p', userPrompt,
+    ];
+}
+/**
+ * Build the spawn argv + cwd. Exported for tests.
+ */
+function prepareSmashSpawn(deps, ticket) {
+    const mode = deps.mode === 'full' ? 'full' : 'simple';
+    const systemPrompt = (0, explore_smash_1.buildSmashSystemPrompt)(mode);
+    const userPrompt = `${ticket.title}\n\n${ticket.description}`;
+    let cwd;
+    // Full mode needs access to the project tree (so Read/Grep/Glob hit the
+    // real repo). Simple mode keeps the app-managed dir for a clean scope.
+    if (mode === 'full') {
+        cwd = deps.projectPath;
+    }
+    else {
+        try {
+            cwd = (0, explore_cwd_manager_1.ensureExploreCwd)({
+                slug: deps.projectSlug,
+                projectPath: deps.projectPath,
+                projectName: deps.projectName,
+            });
+        }
+        catch {
+            cwd = deps.projectPath;
+        }
+    }
+    const model = deps.model ?? 'sonnet';
+    return { args: buildSmashArgs(model, systemPrompt, userPrompt, mode), cwd, systemPrompt, userPrompt, mode };
+}
+/**
+ * Read stream-json output from a child process. Exported for tests.
+ */
+function readSmashChildOutput(child, timeoutMs) {
+    return new Promise((resolve) => {
+        let fullText = '';
+        let resultEvent = null;
+        let timedOut = false;
+        let settled = false;
+        if (!child.stdout) {
+            resolve({ fullText, resultEvent, code: -1, timedOut: false });
+            return;
+        }
+        const reader = (0, node_readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+        reader.on('line', (line) => {
+            let parsed = null;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (!parsed)
+                return;
+            const type = parsed.type;
+            if (type === 'result') {
+                resultEvent = parsed;
+            }
+            else if (type === 'assistant') {
+                const message = parsed.message;
+                const blocks = message?.content ?? [];
+                for (const b of blocks) {
+                    if (b.type === 'text' && typeof b.text === 'string')
+                        fullText += b.text;
+                }
+            }
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { /* best effort */ }
+            if (!settled) {
+                settled = true;
+                resolve({ fullText, resultEvent, code: null, timedOut: true });
+            }
+        }, timeoutMs);
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            resolve({ fullText, resultEvent, code, timedOut });
+        });
+        child.on('error', () => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            resolve({ fullText, resultEvent, code: -1, timedOut });
+        });
+    });
+}
+/**
+ * Compose the final markdown description persisted for a Sub-Spec.
+ * Appends "Why this Sub-Spec" (rationale) and "Acceptance Criteria" sections
+ * when those fields are populated (full mode). Simple mode leaves the agent's
+ * description as-is.
+ */
+function composeChildDescription(child) {
+    const parts = [child.description.trim()];
+    if (child.rationale && child.rationale.trim().length > 0) {
+        parts.push('', '## Why this Sub-Spec', '', child.rationale.trim());
+    }
+    if (child.acceptanceCriteria && child.acceptanceCriteria.length > 0) {
+        parts.push('', '## Acceptance Criteria', '');
+        for (const ac of child.acceptanceCriteria) {
+            parts.push(`- ${ac}`);
+        }
+    }
+    return parts.join('\n');
+}
+/**
+ * Inside a single `mutateStore` callback, flip the parent to épica and
+ * insert N child tickets. Returns the updated épica plus the inserted
+ * children. Throws if the ticket disappears between the gate check and
+ * the lock (rare race).
+ */
+function applySmashToStore(filePath, epicId, children, nowIso, createdBy) {
+    let epic = null;
+    const inserted = [];
+    (0, ticket_store_2.mutateStore)(filePath, (s) => {
+        const target = s.tickets[String(epicId)];
+        if (!target)
+            throw new Error(`épica ${epicId} not found inside mutation`);
+        target.is_epic = true;
+        // Stash the pre-SMASH status so undo can restore it. Only stash on first
+        // SMASH (re-SMASH already done) — if already done, leave the original
+        // stash in place.
+        if (!target.metadata)
+            target.metadata = {};
+        const md = target.metadata;
+        if (!md.pre_smash_status) {
+            md.pre_smash_status = target.status;
+        }
+        // Mark the épica as done so it leaves the active backlog and only the
+        // Sub-Specs remain as actionable work.
+        target.status = 'done';
+        target.updated_at = nowIso;
+        epic = target;
+        for (const child of children) {
+            const id = s.next_id++;
+            const description = composeChildDescription(child);
+            const ticket = {
+                id,
+                title: child.title,
+                description,
+                status: 'todo',
+                priority: child.priority,
+                labels: [],
+                assignee: null,
+                prerequisites: [],
+                metadata: {},
+                comments: [],
+                attachments: [],
+                origin_conversation_id: null,
+                is_epic: false,
+                parent_epic_id: epicId,
+                execution_order: child.executionOrder,
+                short_summary: (0, ticket_store_1.clampShortSummary)(child.shortSummary),
+                created_at: nowIso,
+                updated_at: nowIso,
+                created_by: createdBy,
+                source: 'specs-smash',
+            };
+            s.tickets[String(id)] = ticket;
+            inserted.push(ticket);
+        }
+    });
+    if (!epic)
+        throw new Error('mutation did not yield épica');
+    return { epic, children: inserted, smashedAt: nowIso };
+}
+/**
+ * Undo a SMASH: clear `is_epic` on the parent and delete every child whose
+ * `parent_epic_id` matches AND whose `created_at >= smashedAt`. Returns the
+ * ids of the deleted children plus the updated épica (or null when no épica
+ * exists / no longer flagged).
+ */
+function applySmashUndo(filePath, epicId, smashedAt, nowIso) {
+    let epic = null;
+    const deletedChildren = [];
+    (0, ticket_store_2.mutateStore)(filePath, (s) => {
+        const target = s.tickets[String(epicId)];
+        if (!target)
+            return;
+        if (!target.is_epic)
+            return;
+        for (const idStr of Object.keys(s.tickets)) {
+            const t = s.tickets[idStr];
+            if (t.parent_epic_id === epicId && t.created_at >= smashedAt) {
+                deletedChildren.push(t.id);
+                delete s.tickets[idStr];
+            }
+        }
+        target.is_epic = false;
+        // Restore the pre-SMASH status from metadata if available.
+        // B61: 'done' was missing from this whitelist, so undoing a SMASH on a ticket
+        // that was 'done' before silently demoted it to 'todo'. Include every valid
+        // non-epic status.
+        const md = (target.metadata ?? {});
+        if (md.pre_smash_status === 'todo' || md.pre_smash_status === 'in_progress'
+            || md.pre_smash_status === 'cancelled' || md.pre_smash_status === 'draft'
+            || md.pre_smash_status === 'done') {
+            target.status = md.pre_smash_status;
+        }
+        else {
+            target.status = 'todo';
+        }
+        delete md.pre_smash_status;
+        target.updated_at = nowIso;
+        epic = target;
+    });
+    return { epic, deletedChildren };
+}
+/**
+ * Delete all children of an épica without undoing the épica flip itself.
+ * Used by the Re-SMASH flow.
+ */
+function applyDeleteEpicChildren(filePath, epicId) {
+    const deletedChildren = [];
+    const store = (0, ticket_store_2.mutateStore)(filePath, (s) => {
+        for (const idStr of Object.keys(s.tickets)) {
+            const t = s.tickets[idStr];
+            if (t.parent_epic_id === epicId) {
+                deletedChildren.push(t.id);
+                delete s.tickets[idStr];
+            }
+        }
+    });
+    return { deletedChildren, revision: store.revision };
+}
+// ─── recordInvocation wrapper ────────────────────────────────────────────────
+function recordSafely(deps, ticketId, runId, startedAt, finishedAt, status, resultEvent, model) {
+    try {
+        const normalised = resultEvent ? (0, result_event_1.normaliseResultEvent)(resultEvent, 'claude') : {};
+        (0, ai_invocations_1.recordInvocation)(deps.db, {
+            id: (0, node_crypto_1.randomUUID)(),
+            project_id: deps.projectId,
+            provider: 'claude',
+            surface: 'smash',
+            surface_ref_id: `smash:${runId}`,
+            conversation_id: null,
+            ticket_id: ticketId,
+            status,
+            started_at: startedAt,
+            finished_at: finishedAt,
+            ...normalised,
+            model: resultEvent?.model ?? model ?? undefined,
+        });
+    }
+    catch (err) {
+        console.error('[smash-runner] recordInvocation failed:', err);
+    }
+}
+/**
+ * On a successful SMASH, attribute the spawn cost/tokens proportionally to
+ * each Sub-Spec so the per-child spending line is populated immediately.
+ * Cost / tokens / duration are split evenly across N children; num_turns is
+ * floor(turns/N) per row (small loss of precision, acceptable).
+ */
+function recordChildrenInvocations(deps, childrenIds, runId, startedAt, finishedAt, resultEvent, model) {
+    if (childrenIds.length === 0 || !resultEvent)
+        return;
+    try {
+        const normalised = (0, result_event_1.normaliseResultEvent)(resultEvent, 'claude');
+        const n = childrenIds.length;
+        const split = (v) => {
+            if (v === null || v === undefined)
+                return undefined;
+            return v / n;
+        };
+        const splitInt = (v) => {
+            if (v === null || v === undefined)
+                return undefined;
+            return Math.floor(v / n);
+        };
+        for (const childId of childrenIds) {
+            (0, ai_invocations_1.recordInvocation)(deps.db, {
+                id: (0, node_crypto_1.randomUUID)(),
+                project_id: deps.projectId,
+                provider: 'claude',
+                surface: 'smash',
+                surface_ref_id: `smash:${runId}:child:${childId}`,
+                conversation_id: null,
+                ticket_id: childId,
+                status: 'success',
+                started_at: startedAt,
+                finished_at: finishedAt,
+                duration_ms: split(normalised.duration_ms),
+                duration_api_ms: split(normalised.duration_api_ms),
+                tokens_in: splitInt(normalised.tokens_in),
+                tokens_out: splitInt(normalised.tokens_out),
+                tokens_cache_read: splitInt(normalised.tokens_cache_read),
+                tokens_cache_create: splitInt(normalised.tokens_cache_create),
+                total_cost_usd: split(normalised.total_cost_usd),
+                num_turns: splitInt(normalised.num_turns),
+                session_id: normalised.session_id,
+                model: resultEvent.model ?? model ?? undefined,
+            });
+        }
+    }
+    catch (err) {
+        console.error('[smash-runner] recordChildrenInvocations failed:', err);
+    }
+}
+// ─── Public runner ───────────────────────────────────────────────────────────
+/**
+ * Fire a SMASH attempt for a single ticket.
+ */
+// B60: in-process guard against concurrent SMASH of the same ticket. Eligibility
+// is checked pre-spawn (not under the store lock), so two near-simultaneous
+// requests would both pass the gate and each spawn a child set → duplicates.
+// Keyed by `${projectId}:${ticketId}` so distinct projects don't collide.
+const _smashInFlight = new Set();
+async function runSmash(deps, ticketId) {
+    const now = deps.now ?? (() => new Date());
+    const mode = deps.mode === 'full' ? 'full' : 'simple';
+    const defaultTimeout = mode === 'full' ? SMASH_TIMEOUT_MS_FULL : SMASH_TIMEOUT_MS_SIMPLE;
+    const timeoutMs = deps.timeoutMs ?? defaultTimeout;
+    const spawn = deps.spawn ?? cli_prompt_1.spawnAiCli;
+    const runId = (0, node_crypto_1.randomUUID)();
+    console.log(`[smash-runner] entry ticket=${ticketId} run=${runId}`);
+    if ((0, explore_smash_1.isSpecsSmashKillSwitchActive)()) {
+        return { ok: false, reason: 'disabled', ticketId, runId };
+    }
+    // B60: reject a concurrent SMASH of the same ticket. The has-check + add are
+    // synchronous (no await between them), so they close the TOCTOU window the
+    // pre-flight eligibility check leaves open. Released in the finally below.
+    const inFlightKey = `${deps.projectId}:${ticketId}`;
+    if (_smashInFlight.has(inFlightKey)) {
+        return { ok: false, reason: 'in-progress', ticketId, runId };
+    }
+    _smashInFlight.add(inFlightKey);
+    try {
+        // Pre-flight: read store and check eligibility.
+        const filePath = (0, ticket_store_2.resolveTicketStoragePath)(deps.projectPath);
+        let ticket;
+        try {
+            const { readStore } = await Promise.resolve().then(() => __importStar(require('./ticket-store')));
+            const store = readStore(filePath);
+            const gate = checkSmashEligibility(store, ticketId);
+            if (!gate.ok) {
+                return { ok: false, reason: gate.reason, ticketId, runId };
+            }
+            ticket = gate.context.ticket;
+        }
+        catch (err) {
+            console.error('[smash-runner] pre-flight read failed:', err);
+            return { ok: false, reason: 'crashed', ticketId, runId };
+        }
+        // Broadcast start.
+        const startedAt = now().toISOString();
+        deps.broadcast({
+            type: 'smash.started',
+            projectId: deps.projectId,
+            ticketId,
+            runId,
+            ticketTitle: ticket.title,
+            timestamp: startedAt,
+        });
+        const { args, cwd } = prepareSmashSpawn({
+            projectSlug: deps.projectSlug,
+            projectPath: deps.projectPath,
+            projectName: deps.projectName,
+            model: deps.model,
+        }, ticket);
+        let child;
+        try {
+            child = spawn('claude', args, {
+                env: process.env,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                cwd,
+            });
+        }
+        catch (err) {
+            const finishedAt = now().toISOString();
+            recordSafely(deps, ticketId, runId, startedAt, finishedAt, 'failed', null, deps.model);
+            deps.broadcast({
+                type: 'smash.failed',
+                projectId: deps.projectId,
+                ticketId,
+                runId,
+                reason: 'crashed',
+                timestamp: finishedAt,
+            });
+            return { ok: false, reason: 'crashed', ticketId, runId };
+        }
+        // Synthesize progress pills as the spawn proceeds. The runner uses fixed
+        // offsets — cheap and deterministic vs trying to read tool-use events.
+        const progressTimers = [];
+        const stages = ['analyzing', 'identifying', 'ordering'];
+        stages.forEach((stage, i) => {
+            progressTimers.push(setTimeout(() => {
+                deps.broadcast({
+                    type: 'smash.progress',
+                    projectId: deps.projectId,
+                    ticketId,
+                    runId,
+                    stage,
+                    timestamp: now().toISOString(),
+                });
+            }, 200 + i * 1500));
+        });
+        const result = await readSmashChildOutput(child, timeoutMs);
+        progressTimers.forEach((t) => clearTimeout(t));
+        const finishedAt = now().toISOString();
+        console.log(`[smash-runner] spawn done code=${result.code} timedOut=${result.timedOut} hasResult=${!!result.resultEvent} textBytes=${result.fullText.length}`);
+        if (result.timedOut) {
+            recordSafely(deps, ticketId, runId, startedAt, finishedAt, 'aborted', result.resultEvent, deps.model);
+            deps.broadcast({
+                type: 'smash.failed',
+                projectId: deps.projectId,
+                ticketId,
+                runId,
+                reason: 'timeout',
+                timestamp: finishedAt,
+            });
+            return { ok: false, reason: 'timeout', ticketId, runId };
+        }
+        if (result.code !== 0 || !result.resultEvent) {
+            recordSafely(deps, ticketId, runId, startedAt, finishedAt, 'failed', result.resultEvent, deps.model);
+            const reason = result.resultEvent ? 'model_error' : 'crashed';
+            deps.broadcast({
+                type: 'smash.failed',
+                projectId: deps.projectId,
+                ticketId,
+                runId,
+                reason,
+                timestamp: finishedAt,
+            });
+            return { ok: false, reason, ticketId, runId };
+        }
+        const parse = (0, explore_smash_1.parseSmashOutput)(result.fullText);
+        if (!parse.ok) {
+            console.log(`[smash-runner] parse failed reason=${parse.reason} detail=${parse.detail ?? '-'}`);
+            recordSafely(deps, ticketId, runId, startedAt, finishedAt, 'failed', result.resultEvent, deps.model);
+            deps.broadcast({
+                type: 'smash.failed',
+                projectId: deps.projectId,
+                ticketId,
+                runId,
+                reason: 'invalid-output',
+                detail: parse.reason,
+                timestamp: finishedAt,
+            });
+            return { ok: false, reason: 'invalid-output', ticketId, runId };
+        }
+        // Atomic flip + insert.
+        let applied;
+        try {
+            applied = applySmashToStore(filePath, ticketId, parse.value.children, finishedAt, 'sr-specs-smash');
+        }
+        catch (err) {
+            console.error('[smash-runner] mutation failed:', err);
+            recordSafely(deps, ticketId, runId, startedAt, finishedAt, 'failed', result.resultEvent, deps.model);
+            deps.broadcast({
+                type: 'smash.failed',
+                projectId: deps.projectId,
+                ticketId,
+                runId,
+                reason: 'mutation-failed',
+                timestamp: finishedAt,
+            });
+            return { ok: false, reason: 'mutation-failed', ticketId, runId };
+        }
+        // On a successful SMASH, attribute the spawn cost ONLY to the children
+        // (cost split evenly). The Epic itself does not accrue cost here — the
+        // operation logically birthed the Sub-Specs and the cost belongs to them.
+        // Total project cost remains the original spawn cost (sum of N × X/N = X).
+        recordChildrenInvocations(deps, applied.children.map((c) => c.id), runId, startedAt, finishedAt, result.resultEvent, deps.model);
+        // Broadcast underlying state changes first, then the SMASH-specific event.
+        deps.broadcast({
+            type: 'ticket_updated',
+            ticket: applied.epic,
+            projectId: deps.projectId,
+            timestamp: finishedAt,
+        });
+        for (const child of applied.children) {
+            deps.broadcast({
+                type: 'ticket_created',
+                ticket: child,
+                projectId: deps.projectId,
+                timestamp: finishedAt,
+            });
+        }
+        deps.broadcast({
+            type: 'smash.completed',
+            projectId: deps.projectId,
+            ticketId,
+            runId,
+            smashedAt: finishedAt,
+            childrenIds: applied.children.map((c) => c.id),
+            timestamp: finishedAt,
+        });
+        deps.broadcast({ type: 'spending.invalidated', projectId: deps.projectId });
+        return {
+            ok: true,
+            ticketId,
+            runId,
+            childrenIds: applied.children.map((c) => c.id),
+        };
+    }
+    finally {
+        // B60: always release the in-flight guard (success, failure, or throw).
+        _smashInFlight.delete(inFlightKey);
+    }
+}
+/**
+ * Undo a prior SMASH: deletes any child created since `smashedAt` and clears
+ * `is_epic` on the parent ticket.
+ */
+async function runSmashUndo(deps, ticketId, smashedAt) {
+    if ((0, explore_smash_1.isSpecsSmashKillSwitchActive)()) {
+        return { ok: false, deletedChildren: [], reason: 'disabled' };
+    }
+    const now = deps.now ?? (() => new Date());
+    const filePath = (0, ticket_store_2.resolveTicketStoragePath)(deps.projectPath);
+    const finishedAt = now().toISOString();
+    let undone;
+    try {
+        undone = applySmashUndo(filePath, ticketId, smashedAt, finishedAt);
+    }
+    catch (err) {
+        console.error('[smash-runner] undo failed:', err);
+        return { ok: false, deletedChildren: [], reason: 'mutation-failed' };
+    }
+    if (!undone.epic) {
+        return { ok: false, deletedChildren: [], reason: 'ticket-not-found' };
+    }
+    for (const id of undone.deletedChildren) {
+        deps.broadcast({
+            type: 'ticket_deleted',
+            ticketId: id,
+            projectId: deps.projectId,
+            timestamp: finishedAt,
+        });
+    }
+    deps.broadcast({
+        type: 'ticket_updated',
+        ticket: undone.epic,
+        projectId: deps.projectId,
+        timestamp: finishedAt,
+    });
+    deps.broadcast({
+        type: 'smash.undone',
+        projectId: deps.projectId,
+        ticketId,
+        childrenIds: undone.deletedChildren,
+        timestamp: finishedAt,
+    });
+    return { ok: true, deletedChildren: undone.deletedChildren };
+}