specrails-desktop 2.64.1 → 2.65.0

package/server/dist/modules/specs/runtime/spec-history.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseRunId = baseRunId;
+exports.actorOf = actorOf;
+exports.collectSpecHistory = collectSpecHistory;
+const delivery_evidence_1 = require("../../delivery/runtime/delivery-evidence");
+const sqlite_1 = require("../../recovery/adapters/sqlite");
+const audit_1 = require("../../audit");
+const spec_addenda_core_1 = require("./spec-addenda-core");
+const timeline_1 = require("../domain/timeline");
+/** Hard bounds so a pathological history cannot blow up one request. */
+const MAX_INVOCATIONS = 2000;
+const MAX_RUNS = 200;
+const MAX_DELIVERIES = 50;
+const SPEC_AI_SURFACES = new Set(['ai-edit', 'quick-spec', 'smash', 'triage', 'spec-launcher']);
+const MISSION_SURFACES = new Set(['explore-spec', 'chat-sidebar', 'flow']);
+function placeholders(count) {
+    return Array.from({ length: count }, () => '?').join(', ');
+}
+function chunk(items, size) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}
+function parseJson(raw, fallback) {
+    if (!raw)
+        return fallback;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+/** `job-1#t7` and `job-1:merge:step` rows belong to job `job-1`. */
+function baseRunId(refId) {
+    if (!refId)
+        return null;
+    return refId.replace(/#t\d+$/, '').replace(/:merge:.*$/, '') || null;
+}
+function actorOf(createdBy, provider = null) {
+    const by = (createdBy ?? '').trim();
+    if (by === 'mcp')
+        return { type: 'mcp', label: 'mcp', provider };
+    if (by === 'user' || by === 'manual' || by === '')
+        return { type: 'user', label: 'user', provider: null };
+    if (by === 'agent' || by.startsWith('sr') || by.startsWith('specrails'))
+        return { type: 'agent', label: by.replace(/^(?:specrails:|sr:|sr-)/, '') || 'agent', provider };
+    return { type: 'system', label: by, provider };
+}
+/** Markdown to plain prose, so a summary never shows `**Tracker:**` or `## Heading` literally. */
+function plain(text) {
+    if (typeof text !== 'string')
+        return text;
+    return text
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/^\s*[-*#>]+\s*/gm, '')
+        .replace(/\s+/g, ' ');
+}
+function clean(text, max = 240) {
+    const flat = (0, timeline_1.oneLine)(plain(text), max);
+    return flat === null ? null : (0, audit_1.redactProse)(flat);
+}
+function runTone(status, outcome) {
+    if (status === 'running' || status === 'queued' || status === 'paused')
+        return 'neutral';
+    if (outcome === 'failed' || outcome === 'blocked' || outcome === 'stalled' || status === 'failed' || status === 'canceled' || status === 'aborted')
+        return 'failure';
+    return 'ok';
+}
+function collectSpecHistory(db, ticket) {
+    const ticketId = ticket.id;
+    const entries = [];
+    const specLink = { place: 'spec', id: String(ticketId) };
+    // ─── Ticket: creation, last edit, comments ────────────────────────────────
+    entries.push({
+        id: 'spec:created', at: (0, timeline_1.utc)(ticket.created_at), kind: 'spec_edit', event: 'spec.created',
+        params: { source: ticket.source }, title: 'Spec created', summary: clean(ticket.title),
+        actor: actorOf(ticket.created_by), tone: 'neutral', provider: null,
+        link: ticket.origin_conversation_id ? { place: 'mission', id: ticket.origin_conversation_id } : specLink,
+    });
+    const updatedMs = Date.parse((0, timeline_1.utc)(ticket.updated_at));
+    if (Number.isFinite(updatedMs) && updatedMs - Date.parse((0, timeline_1.utc)(ticket.created_at)) > 1000) {
+        entries.push({
+            id: 'spec:updated', at: (0, timeline_1.utc)(ticket.updated_at), kind: 'spec_edit', event: 'spec.updated',
+            params: { status: ticket.status }, title: 'Spec last edited', summary: null,
+            actor: null, tone: 'neutral', provider: null, link: specLink,
+        });
+    }
+    for (const comment of ticket.comments ?? []) {
+        entries.push({
+            id: `spec:comment:${comment.id}`, at: (0, timeline_1.utc)(comment.created_at), kind: 'spec_edit', event: 'spec.comment',
+            params: {}, title: 'Comment', summary: clean(comment.body, 400), actor: actorOf(comment.created_by),
+            tone: 'neutral', provider: null, link: specLink,
+        });
+    }
+    // ─── Addenda ───────────────────────────────────────────────────────────────
+    for (const addendum of (0, spec_addenda_core_1.readSpecAddenda)(ticket.addenda)) {
+        entries.push({
+            id: `addendum:${addendum.id}:created`, at: (0, timeline_1.utc)(addendum.created_at), kind: 'addendum', event: 'addendum.created',
+            params: { addendumKind: addendum.kind }, title: clean(addendum.title, 200) ?? addendum.kind,
+            summary: clean(addendum.body, 400), actor: actorOf(addendum.created_by), tone: 'neutral', provider: null,
+            link: addendum.origin_conversation_id ? { place: 'mission', id: addendum.origin_conversation_id } : specLink,
+        });
+        if (addendum.status !== 'open') {
+            entries.push({
+                id: `addendum:${addendum.id}:${addendum.status}`, at: (0, timeline_1.utc)(addendum.applied_at ?? addendum.updated_at), kind: 'addendum',
+                event: `addendum.${addendum.status}`, params: { addendumKind: addendum.kind }, title: clean(addendum.title, 200) ?? addendum.kind,
+                summary: null, actor: null, tone: addendum.status === 'applied' ? 'ok' : 'neutral', provider: null,
+                link: addendum.run_id ? { place: 'job', id: addendum.run_id } : specLink,
+            });
+        }
+    }
+    // ─── Invocation ledger: the spine for cost, missions, AI edits and runs ───
+    const invocationRows = db.prepare(`
+    SELECT id, surface, surface_ref_id, conversation_id, loop_run_id, provider, model, status, started_at,
+           total_cost_usd, total_cost_usd_estimated, num_turns
+    FROM ai_invocations WHERE ticket_id = ? ORDER BY started_at DESC LIMIT ${MAX_INVOCATIONS}
+  `).all(ticketId);
+    const invocations = invocationRows.map((row) => ({
+        id: row.id, surface: row.surface, refId: row.surface_ref_id, conversationId: row.conversation_id, loopRunId: row.loop_run_id,
+        provider: row.provider, model: row.model, status: row.status, startedAt: (0, timeline_1.utc)(row.started_at),
+        costUsd: row.total_cost_usd, estimated: row.total_cost_usd_estimated === 1, turns: row.num_turns,
+    }));
+    const costOf = (rows) => (0, timeline_1.foldCost)(rows.map((r) => ({ provider: r.provider, costUsd: r.costUsd, estimated: r.estimated, turns: r.turns })));
+    const providerOf = (rows) => {
+        const set = new Set(rows.map((r) => r.provider).filter((p) => !!p));
+        return set.size === 1 ? [...set][0] : null;
+    };
+    // AI edits and generation touching the spec: one entry each (low volume).
+    for (const inv of invocations) {
+        if (!SPEC_AI_SURFACES.has(inv.surface))
+            continue;
+        const cost = costOf([inv]);
+        entries.push({
+            id: `ai:${inv.id}`, at: inv.startedAt, kind: 'spec_edit', event: `spec.ai.${inv.surface}`,
+            params: { surface: inv.surface, status: inv.status }, title: `AI ${inv.surface}`, summary: null,
+            actor: { type: 'agent', label: inv.surface, provider: inv.provider }, tone: inv.status === 'failed' ? 'failure' : 'neutral',
+            provider: inv.provider, ...cost, link: specLink,
+        });
+    }
+    // Mission turns: grouped per conversation.
+    const byConversation = new Map();
+    for (const inv of invocations) {
+        if (!inv.conversationId || !MISSION_SURFACES.has(inv.surface))
+            continue;
+        const list = byConversation.get(inv.conversationId) ?? [];
+        list.push(inv);
+        byConversation.set(inv.conversationId, list);
+    }
+    const conversationIds = [...byConversation.keys()];
+    const titles = new Map();
+    for (const ids of chunk(conversationIds, 500)) {
+        const rows = db.prepare(`SELECT id, title FROM chat_conversations WHERE id IN (${placeholders(ids.length)})`).all(...ids);
+        for (const row of rows)
+            titles.set(row.id, row.title);
+    }
+    for (const [conversationId, rows] of byConversation) {
+        if (!titles.has(conversationId))
+            continue; // conversation was deleted: nothing to link to, nothing to show
+        const sorted = [...rows].sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+        const items = sorted.slice(0, timeline_1.TIMELINE_MAX_ITEMS).map((inv) => ({
+            at: inv.startedAt, label: inv.surface, detail: inv.model, ...(inv.status === 'failed' ? { tone: 'failure' } : {}),
+        }));
+        entries.push({
+            id: `mission:${conversationId}`, at: sorted[0].startedAt, kind: 'mission_turn', event: 'mission.turns',
+            params: { turns: rows.length }, title: clean(titles.get(conversationId) ?? null, 160) ?? 'Mission', summary: null,
+            actor: { type: 'agent', label: 'mission', provider: providerOf(rows) }, tone: 'neutral', provider: providerOf(rows),
+            ...costOf(rows), link: { place: 'mission', id: conversationId }, count: rows.length, items,
+        });
+    }
+    // ─── Deliveries (needed to find runs too) ─────────────────────────────────
+    const deliveryRows = db.prepare(`
+    SELECT * FROM rail_pr_deliveries
+    WHERE parent_delivery_id IS NULL
+      AND EXISTS (SELECT 1 FROM json_each(rail_pr_deliveries.ticket_ids) WHERE value = ?)
+    ORDER BY created_at DESC LIMIT ${MAX_DELIVERIES}
+  `).all(ticketId);
+    const deliveries = deliveryRows.map((row) => {
+        const evidence = (0, delivery_evidence_1.readSettleEvidence)(row.settle_evidence);
+        const unit = evidence?.units.find((u) => u.ticketId === ticketId) ?? null;
+        return {
+            id: String(row.id), loopName: String(row.loop_name ?? ''), decision: String(row.decision), statusCode: row.status_code ?? null,
+            statusDetail: row.status_detail ?? null, branch: row.branch ?? null, baseBranch: String(row.base_branch ?? ''),
+            prUrl: row.pr_url ?? null, prNumber: row.pr_number ?? null, prState: String(row.pr_state ?? 'none'),
+            originConversationId: row.origin_conversation_id ?? null, createdAt: (0, timeline_1.utc)(String(row.created_at)),
+            onReviewAt: (0, timeline_1.utc)(row.on_review_at ?? null), publishedAt: (0, timeline_1.utc)(row.published_at ?? null),
+            mergedAt: (0, timeline_1.utc)(row.merged_at ?? null), decidedAt: (0, timeline_1.utc)(row.decided_at ?? null), updatedAt: (0, timeline_1.utc)(String(row.updated_at)),
+            ticketIds: parseJson(row.ticket_ids, []),
+            review: unit && evidence ? reviewFact(unit.runtime ?? null, unit.sentinel, unit.sentinelDetail, (0, timeline_1.utc)(evidence.harvestedAt)) : null,
+        };
+    });
+    const deliveryRunIds = deliveryRows.flatMap((row) => parseJson(row.run_ids, []).filter((v) => typeof v === 'string'));
+    // ─── Runs and jobs ────────────────────────────────────────────────────────
+    const runIdSet = new Set();
+    for (const inv of invocations) {
+        if (inv.surface === 'job') {
+            const id = baseRunId(inv.refId);
+            if (id)
+                runIdSet.add(id);
+        }
+        if (inv.loopRunId)
+            runIdSet.add(inv.loopRunId);
+    }
+    for (const id of deliveryRunIds)
+        runIdSet.add(id);
+    const loopRunMatches = db.prepare(`
+    SELECT id FROM loop_runs
+    WHERE ticket_id = ? OR EXISTS (SELECT 1 FROM json_each(COALESCE(loop_runs.ticket_ids_json, '[]')) WHERE value = ?)
+    ORDER BY started_at DESC LIMIT ${MAX_RUNS}
+  `).all(ticketId, ticketId);
+    for (const row of loopRunMatches)
+        runIdSet.add(row.id);
+    const runs = [];
+    for (const ids of chunk([...runIdSet], 400)) {
+        const marks = placeholders(ids.length);
+        const loopRows = db.prepare(`SELECT id, loop_name, provider, model, status, final_outcome, started_at, finished_at FROM loop_runs WHERE id IN (${marks})`).all(...ids);
+        for (const row of loopRows)
+            runs.push({ ...row, started_at: (0, timeline_1.utc)(row.started_at), finished_at: (0, timeline_1.utc)(row.finished_at), source: 'run', command: null });
+        const seen = new Set(loopRows.map((r) => r.id));
+        const rest = ids.filter((id) => !seen.has(id));
+        if (rest.length > 0) {
+            const jobRows = db.prepare(`SELECT id, command, provider, model, status, started_at, finished_at FROM jobs WHERE id IN (${placeholders(rest.length)})`).all(...rest);
+            for (const row of jobRows)
+                runs.push({ id: row.id, loop_name: null, provider: row.provider, model: row.model, status: row.status, final_outcome: null, started_at: (0, timeline_1.utc)(row.started_at), finished_at: (0, timeline_1.utc)(row.finished_at), source: 'job', command: row.command });
+        }
+    }
+    runs.sort((a, b) => (a.started_at < b.started_at ? 1 : -1));
+    const shownRuns = runs.slice(0, MAX_RUNS);
+    const runIds = shownRuns.map((r) => r.id);
+    const invocationsOfRun = (id) => invocations.filter((inv) => baseRunId(inv.refId) === id || inv.loopRunId === id);
+    for (const run of shownRuns) {
+        const mine = invocationsOfRun(run.id);
+        const tone = runTone(run.status, run.final_outcome);
+        const diagnosis = tone === 'failure' ? safeDiagnosis(db, run.id, run.status) : null;
+        const duration = run.finished_at ? Math.max(0, Date.parse(run.finished_at) - Date.parse(run.started_at)) : null;
+        entries.push({
+            id: `job:${run.id}`, at: run.started_at, kind: 'job', event: 'job.run',
+            params: { status: run.status, outcome: run.final_outcome, durationMs: Number.isFinite(duration) ? duration : null, failureKind: diagnosis?.kind ?? null },
+            title: clean(run.loop_name ?? run.command ?? run.id, 160) ?? run.id,
+            summary: clean(diagnosis?.detail ?? null),
+            actor: { type: 'agent', label: run.loop_name ? 'loop' : 'job', provider: run.provider ?? providerOf(mine) },
+            tone, provider: run.provider ?? providerOf(mine), ...costOf(mine), link: { place: 'job', id: run.id },
+        });
+    }
+    // Phases: grouped per job.
+    if (runIds.length > 0) {
+        const phaseRows = [];
+        for (const ids of chunk(runIds, 400)) {
+            phaseRows.push(...db.prepare(`SELECT job_id, phase, state, updated_at FROM job_phases WHERE job_id IN (${placeholders(ids.length)})`).all(...ids));
+        }
+        const byJob = new Map();
+        for (const row of phaseRows) {
+            const l = byJob.get(row.job_id) ?? [];
+            l.push(row);
+            byJob.set(row.job_id, l);
+        }
+        for (const [jobId, rows] of byJob) {
+            rows.sort((a, b) => (a.updated_at < b.updated_at ? -1 : 1));
+            const failed = rows.filter((r) => r.state === 'failed' || r.state === 'error').length;
+            entries.push({
+                id: `phases:${jobId}`, at: (0, timeline_1.utc)(rows[rows.length - 1].updated_at), kind: 'phase', event: 'phase.group',
+                params: { count: rows.length, failed }, title: `${rows.length} phases`, summary: clean(rows.map((r) => r.phase).join(' → '), 200),
+                actor: null, tone: failed > 0 ? 'failure' : 'neutral', provider: null, link: { place: 'job', id: jobId }, count: rows.length,
+                items: rows.slice(0, timeline_1.TIMELINE_MAX_ITEMS).map((r) => ({ at: (0, timeline_1.utc)(r.updated_at), label: r.phase, detail: r.state, ...(r.state === 'failed' || r.state === 'error' ? { tone: 'failure' } : {}) })),
+            });
+        }
+        // Agent actions audit: grouped per run.
+        const actionRows = [];
+        for (const ids of chunk(runIds, 200)) {
+            const marks = placeholders(ids.length);
+            actionRows.push(...db.prepare(`SELECT run_id, job_id, role, kind, target, ts FROM agent_actions WHERE run_id IN (${marks}) OR job_id IN (${marks}) ORDER BY ts DESC LIMIT 5000`).all(...ids, ...ids));
+        }
+        const known = new Set(runIds);
+        const byRun = new Map();
+        for (const row of actionRows) {
+            const key = known.has(row.run_id) ? row.run_id : row.job_id && known.has(row.job_id) ? row.job_id : null;
+            if (!key)
+                continue;
+            const l = byRun.get(key) ?? [];
+            l.push(row);
+            byRun.set(key, l);
+        }
+        for (const [runId, rows] of byRun) {
+            const counts = { read: 0, write: 0, exec: 0, mcp: 0, network: 0 };
+            for (const row of rows)
+                counts[row.kind] = (counts[row.kind] ?? 0) + 1;
+            // Reads dominate and say little: details lead with what changed or ran.
+            const notable = rows.filter((r) => r.kind !== 'read');
+            const roles = [...new Set(rows.map((r) => r.role))];
+            entries.push({
+                id: `audit:${runId}`, at: (0, timeline_1.utc)(rows.reduce((max, r) => (r.ts > max ? r.ts : max), rows[0].ts)), kind: 'audit', event: 'audit.group',
+                params: { count: rows.length, ...counts }, title: `${rows.length} agent actions`, summary: null,
+                actor: roles.length === 1 ? { type: 'agent', label: roles[0], provider: null } : null, tone: 'neutral', provider: null,
+                link: { place: 'job', id: runId }, count: rows.length,
+                items: notable.slice(0, timeline_1.TIMELINE_MAX_ITEMS).map((r) => ({ at: (0, timeline_1.utc)(r.ts), label: r.kind, detail: clean(r.target, 200), })),
+            });
+        }
+    }
+    // ─── PR events and review ─────────────────────────────────────────────────
+    for (const d of deliveries) {
+        const link = { place: 'review', id: d.id };
+        const failed = d.decision === 'implementation_failed' || d.decision === 'pr_failed';
+        entries.push({
+            id: `pr:${d.id}:created`, at: d.createdAt, kind: 'pr_event', event: 'pr.delivery_started', params: { loop: d.loopName },
+            title: 'Delivery started', summary: clean(d.loopName), actor: null, tone: 'neutral', provider: null, link,
+        });
+        if (d.onReviewAt) {
+            entries.push({ id: `pr:${d.id}:review`, at: d.onReviewAt, kind: 'pr_event', event: 'pr.ready_for_review', params: {}, title: 'Ready for review', summary: null, actor: null, tone: 'review', provider: null, link });
+        }
+        if (d.publishedAt) {
+            entries.push({
+                id: `pr:${d.id}:published`, at: d.publishedAt, kind: 'pr_event', event: 'pr.published', params: { prNumber: d.prNumber },
+                title: d.prNumber ? `PR #${d.prNumber}` : 'PR published', summary: clean(d.branch), actor: null, tone: 'ok', provider: null, link, url: d.prUrl,
+            });
+        }
+        if (d.mergedAt) {
+            entries.push({ id: `pr:${d.id}:merged`, at: d.mergedAt, kind: 'pr_event', event: 'pr.merged', params: { prNumber: d.prNumber }, title: 'Merged', summary: null, actor: null, tone: 'ok', provider: null, link, url: d.prUrl });
+        }
+        else if (d.decidedAt && (failed || d.decision === 'discarded' || d.decision === 'superseded')) {
+            entries.push({
+                id: `pr:${d.id}:closed`, at: d.decidedAt, kind: 'pr_event', event: `pr.${failed ? 'failed' : d.decision}`, params: { decision: d.decision },
+                title: failed ? 'Delivery failed' : d.decision, summary: clean(d.statusDetail), actor: null, tone: failed ? 'failure' : 'neutral', provider: null, link,
+            });
+        }
+        if (d.review) {
+            const r = d.review;
+            const verdict = r.approved === true ? 'approved' : r.approved === false ? 'changes_requested' : r.sentinel === 'fail' ? 'failed' : 'recorded';
+            entries.push({
+                id: `review:${d.id}`, at: r.harvestedAt, kind: 'review', event: 'review.verdict',
+                params: { verdict, findings: r.findings.length, score: r.score },
+                title: `Review: ${verdict}`, summary: clean(r.summary ?? r.sentinelDetail, 400),
+                actor: { type: 'agent', label: 'reviewer', provider: null }, tone: r.approved === true && r.findings.length === 0 ? 'ok' : 'review', provider: null,
+                link, count: r.findings.length || undefined,
+                items: r.findings.slice(0, timeline_1.TIMELINE_MAX_ITEMS).map((f) => ({ at: null, label: f.text, detail: f.location, tone: 'review' })),
+            });
+        }
+    }
+    return { entries: (0, timeline_1.sortTimeline)(entries), invocations, deliveries, runIds };
+}
+function safeDiagnosis(db, runId, status) {
+    try {
+        const d = (0, sqlite_1.readJobDiagnosis)(db, runId, status);
+        return d ? { kind: d.kind, detail: d.detail } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function reviewFact(runtime, sentinel, sentinelDetail, harvestedAt) {
+    const findingTexts = runtime?.findings ?? [];
+    const locations = new Map();
+    for (const loc of runtime?.findingLocations ?? []) {
+        if (!locations.has(loc.finding)) {
+            const text = (0, timeline_1.formatLocation)(loc);
+            if (text)
+                locations.set(loc.finding, text);
+        }
+    }
+    const issues = runtime?.review?.issues ?? [];
+    const hasSignal = runtime?.review || findingTexts.length > 0 || sentinel !== 'absent';
+    if (!hasSignal)
+        return null;
+    return {
+        harvestedAt,
+        approved: runtime?.review?.approved ?? null,
+        score: runtime?.review?.score ?? null,
+        summary: runtime?.review?.summary ?? null,
+        issues: issues.map((i) => (0, audit_1.redactProse)(String(i))).slice(0, 20),
+        findings: findingTexts.slice(0, 50).map((text, index) => ({ text: (0, audit_1.redactProse)((0, timeline_1.oneLine)(text, 300) ?? ''), location: locations.get(index) ?? null })),
+        sentinel: sentinel === 'absent' ? null : sentinel,
+        sentinelDetail: sentinelDetail ? (0, audit_1.redactProse)(sentinelDetail) : null,
+    };
+}

package/server/dist/modules/specs/runtime/spec-launcher-manager.js

@@ -13,6 +13,7 @@ const providers_1 = require("../../../providers");
 const result_event_1 = require("../../accounting/runtime/result-event");
 const ai_invocations_1 = require("../../accounting/runtime/ai-invocations");
 const runtime_1 = require("../../../providers/runtime");
+const project_env_1 = require("../../../project-env");
 const loop_command_catalog_1 = require("../../loops/runtime/loop-command-catalog");
 const workspace_resolution_1 = require("../../../workspace-resolution");
 // ─── SpecLauncherManager ──────────────────────────────────────────────────────
@@ -159,7 +160,7 @@ class SpecLauncherManager {
             ? `${(0, loop_command_catalog_1.expandCommands)('{{cmd:opsx:ff}}', { provider: this._adapter.id })} ${description}`
             : resolvedPrompt;
         if (providerCommand === rawCommand) {
-            this._broadcastError(launchId, 'This project does not have the /opsx:ff command installed. Run "npx specrails-core@latest" to install it.');
+            this._broadcastError(launchId, 'This project does not have the /opsx:ff command installed. Update Specrails Core from Settings → Updates.');
             return;
         }
         let prompt;
@@ -180,10 +181,10 @@ class SpecLauncherManager {
         };
         const args = this._adapter.buildArgs('spec-gen', spawnOptions);
         const child = (0, cli_prompt_1.spawnAiCli)(this._adapter.binary, args, {
-            env: (0, runtime_1.buildProviderEnv)(this._adapter, spawnOptions, {
+            env: (0, runtime_1.buildProviderEnv)(this._adapter, spawnOptions, (0, project_env_1.projectAgentSourceEnv)(this._db, (0, runtime_1.providerEnvAllowlist)(this._adapter), {
                 ...process.env,
                 ...execution.env,
-            }),
+            })),
             stdio: ['ignore', 'pipe', 'pipe'],
             cwd: execution.cwd,
         });

package/server/dist/modules/specs/runtime/spec-search.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPEC_SEARCH_MAX_LIMIT = exports.SPEC_SEARCH_DEFAULT_LIMIT = void 0;
+exports.searchSpecs = searchSpecs;
+// Spec search for the ⌘K `#` scope (CD6). Specs live in the project's ticket
+// store (a JSON file Core also writes), not in SQLite, so an FTS table would be
+// a second copy to keep in step with external writers. A project holds tens to
+// a few hundred specs: a folded-substring scan over title, summary, description,
+// labels, non-goals, addenda and comments is exact, always current, and cheap.
+// Matching ignores case and diacritics; snippets share the mission highlight
+// shape (text + ranges) so the client renders every scope the same way.
+const ticket_store_1 = require("./ticket-store");
+exports.SPEC_SEARCH_DEFAULT_LIMIT = 8;
+exports.SPEC_SEARCH_MAX_LIMIT = 30;
+const CONTEXT = 60;
+/** Fold to lowercase without diacritics, keeping a map back to original offsets. */
+function foldWithMap(text) {
+    let folded = '';
+    const map = [];
+    let offset = 0;
+    for (const ch of text) {
+        const piece = ch.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+        for (let i = 0; i < piece.length; i++)
+            map.push(offset);
+        folded += piece;
+        offset += ch.length;
+    }
+    map.push(offset);
+    return { folded, map };
+}
+function foldPlain(text) {
+    return foldWithMap(text).folded;
+}
+/** Window of ~CONTEXT characters on each side of the first match, with its range. */
+function snippetAround(text, needle) {
+    const { folded, map } = foldWithMap(text);
+    const at = folded.indexOf(needle);
+    if (at < 0)
+        return null;
+    const matchStart = map[at];
+    const matchEnd = map[Math.min(at + needle.length, folded.length)];
+    const start = Math.max(0, matchStart - CONTEXT);
+    const end = Math.min(text.length, matchEnd + CONTEXT);
+    const prefix = start > 0 ? '…' : '';
+    const suffix = end < text.length ? '…' : '';
+    // Whitespace collapsing keeps ranges honest by working segment by segment.
+    const before = text.slice(start, matchStart).replace(/\s+/g, ' ');
+    const hit = text.slice(matchStart, matchEnd).replace(/\s+/g, ' ');
+    const after = text.slice(matchEnd, end).replace(/\s+/g, ' ');
+    const lead = prefix + before;
+    return { text: lead + hit + after + suffix, ranges: [[lead.length, lead.length + hit.length]] };
+}
+function candidates(ticket) {
+    const out = [{ field: 'title', text: ticket.title ?? '' }];
+    if (ticket.short_summary)
+        out.push({ field: 'summary', text: ticket.short_summary });
+    if (ticket.description)
+        out.push({ field: 'description', text: ticket.description });
+    for (const label of ticket.labels ?? [])
+        out.push({ field: 'label', text: label });
+    for (const goal of ticket.nonGoals ?? [])
+        out.push({ field: 'nonGoal', text: goal });
+    for (const addendum of ticket.addenda ?? []) {
+        out.push({ field: 'addendum', text: addendum.title });
+        out.push({ field: 'addendum', text: addendum.body });
+    }
+    for (const comment of ticket.comments ?? [])
+        out.push({ field: 'comment', text: comment.body });
+    return out;
+}
+const FIELD_RANK = {
+    id: 0, title: 1, summary: 2, label: 3, description: 4, nonGoal: 5, addendum: 6, comment: 7,
+};
+function searchSpecs(tickets, rawQuery, limit = exports.SPEC_SEARCH_DEFAULT_LIMIT) {
+    const query = rawQuery.trim().replace(/^#/, '').trim();
+    if (!query)
+        return [];
+    const cap = Math.max(1, Math.min(exports.SPEC_SEARCH_MAX_LIMIT, Math.floor(limit)));
+    const needle = foldPlain(query);
+    const idQuery = /^\d+$/.test(query) ? Number(query) : null;
+    const scored = [];
+    for (const ticket of tickets) {
+        if ((0, ticket_store_1.isFlowHeldTicket)(ticket))
+            continue;
+        let best = null;
+        if (idQuery !== null && ticket.id === idQuery) {
+            best = { field: 'id', text: ticket.title };
+        }
+        else {
+            for (const c of candidates(ticket)) {
+                if (!foldPlain(c.text).includes(needle))
+                    continue;
+                if (!best || FIELD_RANK[c.field] < FIELD_RANK[best.field])
+                    best = c;
+                if (best.field === 'title')
+                    break;
+            }
+        }
+        if (!best)
+            continue;
+        const startsWithTitle = best.field === 'title' && foldPlain(ticket.title).startsWith(needle);
+        scored.push({
+            hit: {
+                id: ticket.id,
+                title: ticket.title,
+                status: ticket.status,
+                priority: ticket.priority,
+                field: best.field,
+                snippet: best.field === 'id' ? null : snippetAround(best.text, needle),
+            },
+            rank: FIELD_RANK[best.field] * 2 + (startsWithTitle ? 0 : 1),
+            updated: ticket.updated_at ?? '',
+        });
+    }
+    scored.sort((a, b) => a.rank - b.rank || b.updated.localeCompare(a.updated) || b.hit.id - a.hit.id);
+    return scored.slice(0, cap).map((s) => s.hit);
+}

package/server/dist/modules/specs/runtime/ticket-store.js

@@ -3,9 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHORT_SUMMARY_MAX_LEN = exports.CURRENT_SCHEMA_VERSION = void 0;
+exports.REGRESSION_OF_MAX_LEN = exports.SHORT_SUMMARY_MAX_LEN = exports.CURRENT_SCHEMA_VERSION = void 0;
+exports.isFlowHeldTicket = isFlowHeldTicket;
+exports.normalizeRegressionOfMetadata = normalizeRegressionOfMetadata;
+exports.listRegressionLinks = listRegressionLinks;
 exports.clampShortSummary = clampShortSummary;
 exports.resolveTicketStoragePath = resolveTicketStoragePath;
+exports.acquireFileLock = acquireLock;
+exports.releaseFileLock = releaseLock;
 exports.validateEpicChildIntegrity = validateEpicChildIntegrity;
 exports.readStore = readStore;
 exports.applyJobOutcomeToTickets = applyJobOutcomeToTickets;
@@ -20,10 +25,46 @@ exports.validatePriorityForStatus = validatePriorityForStatus;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const spec_addenda_core_1 = require("./spec-addenda-core");
+const non_goals_1 = require("../domain/non-goals");
+/** True while a spec belongs to a live Flow: no Jira write may create or
+ * update an issue for it until the Flow -> Spec rail settles. */
+function isFlowHeldTicket(ticket) {
+    const state = ticket?.metadata?.flow?.state;
+    return state === 'active' || state === 'paused';
+}
 const VALID_STATUSES = new Set(['draft', 'todo', 'in_progress', 'on_review', 'done', 'cancelled']);
 const VALID_PRIORITIES = new Set(['critical', 'high', 'medium', 'low']);
-exports.CURRENT_SCHEMA_VERSION = '1.4';
+exports.CURRENT_SCHEMA_VERSION = '1.5';
 exports.SHORT_SUMMARY_MAX_LEN = 240;
+exports.REGRESSION_OF_MAX_LEN = 200;
+/**
+ * Validate the `regressionOf` key of an incoming metadata patch. Absent ⇒
+ * untouched; `null`/empty ⇒ cleared (key removed); a non-empty string ≤
+ * REGRESSION_OF_MAX_LEN ⇒ trimmed; anything else ⇒ error. Returns the
+ * metadata to merge plus the keys to delete after merging.
+ */
+function normalizeRegressionOfMetadata(metadata) {
+    if (!Object.prototype.hasOwnProperty.call(metadata, 'regressionOf'))
+        return { ok: true, metadata, clear: false };
+    const { regressionOf, ...rest } = metadata;
+    if (regressionOf === null || (typeof regressionOf === 'string' && regressionOf.trim() === '')) {
+        return { ok: true, metadata: rest, clear: true };
+    }
+    if (typeof regressionOf !== 'string' || regressionOf.trim().length > exports.REGRESSION_OF_MAX_LEN) {
+        return { ok: false, error: `metadata.regressionOf must be a delivery id string (max ${exports.REGRESSION_OF_MAX_LEN} chars) or null` };
+    }
+    return { ok: true, metadata: { ...rest, regressionOf: regressionOf.trim() }, clear: false };
+}
+/** Every ticket's escaped-defect link (`metadata.regressionOf`). */
+function listRegressionLinks(store) {
+    const links = [];
+    for (const ticket of Object.values(store.tickets)) {
+        const deliveryId = ticket?.metadata?.regressionOf;
+        if (typeof deliveryId === 'string' && deliveryId.length > 0)
+            links.push({ ticketId: ticket.id, deliveryId });
+    }
+    return links;
+}
 /**
  * Sanitize a `shortSummary` value coming from an AI response or external input.
  * - Returns `null` for nullish, non-string, or empty-after-trim values.
@@ -222,6 +263,10 @@ function normalizeTicket(t) {
     // Schema 1.4 field: spec addenda. Absent ⇒ [], and a malformed entry is
     // dropped rather than crashing the whole store read.
     t.addenda = (0, spec_addenda_core_1.readSpecAddenda)(t.addenda);
+    // Non-goals (3.2): present ⇒ cleaned and bounded; absent stays absent so
+    // older tickets round-trip byte-identically.
+    if (t.nonGoals !== undefined)
+        t.nonGoals = (0, non_goals_1.normalizeNonGoals)(t.nonGoals);
     return t;
 }
 /**

package/server/dist/modules/specs/runtime/ticket-trash-service.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalizeTrashedTicket = finalizeTrashedTicket;
+exports.purgeProjectTrash = purgeProjectTrash;
+exports.startProjectTrashPurge = startProjectTrashPurge;
+const db_1 = require("../../../db");
+const ticket_store_1 = require("./ticket-store");
+const ticket_trash_1 = require("./ticket-trash");
+/**
+ * Run the cascade a hard delete used to run inline: attachments, and the Explore
+ * conversation of a draft nothing else references. Skips a spec that is live
+ * again (a crash leftover) so purge never strips a restored spec of its files.
+ */
+async function finalizeTrashedTicket(deps, entry) {
+    const ticket = entry.ticket;
+    const store = (0, ticket_store_1.readStore)(deps.ticketStorePath());
+    if (store.tickets[String(ticket.id)])
+        return;
+    await deps.deleteAttachments(String(ticket.id)).catch((e) => {
+        console.error('[ticket-trash] attachment cascade delete failed:', e);
+    });
+    const conversationId = ticket.status === 'draft' ? ticket.origin_conversation_id : null;
+    if (!conversationId)
+        return;
+    const stillReferenced = Object.values(store.tickets).some((other) => other.origin_conversation_id === conversationId);
+    if (stillReferenced)
+        return;
+    try {
+        const conv = (0, db_1.getConversation)(deps.db, conversationId);
+        if (conv && conv.kind === 'explore') {
+            (0, db_1.deleteConversation)(deps.db, conversationId);
+            deps.forgetExploreConversation?.(conversationId);
+        }
+    }
+    catch (err) {
+        console.error('[ticket-trash] orphan conversation cleanup failed:', err);
+    }
+}
+/** Purge every expired spec of one project and run their cascades. Idempotent. */
+async function purgeProjectTrash(deps, now = new Date(), retentionMs = ticket_trash_1.TRASH_RETENTION_MS) {
+    let expired;
+    try {
+        expired = (0, ticket_trash_1.purgeExpiredTickets)(deps.ticketStorePath(), now, retentionMs);
+    }
+    catch (err) {
+        console.error('[ticket-trash] purge failed:', err);
+        return 0;
+    }
+    for (const entry of expired)
+        await finalizeTrashedTicket(deps, entry);
+    return expired.length;
+}
+const PURGE_INTERVAL_MS = 6 * 60 * 60 * 1000;
+/** Purge now (startup) and every few hours while the project is loaded. */
+function startProjectTrashPurge(deps) {
+    const run = () => { void purgeProjectTrash(deps); };
+    const first = setTimeout(run, 5_000);
+    const timer = setInterval(run, PURGE_INTERVAL_MS);
+    first.unref?.();
+    timer.unref?.();
+    return { stop: () => { clearTimeout(first); clearInterval(timer); } };
+}