spexcode 0.6.2 → 0.6.6

package/node_modules/@spexcode/spec-forge/dist/drivers/gitlab.js

@@ -0,0 +1,144 @@
+import { execFileSync } from 'node:child_process';
+let ctx = null;
+function gitlabCtx() {
+    if (ctx)
+        return ctx;
+    const remote = execFileSync('git', ['remote', 'get-url', 'origin'], { encoding: 'utf8' }).trim();
+    const parsed = parseRemote(remote);
+    if (!parsed)
+        throw new Error(`gitlab: cannot parse origin remote '${remote}' as a GitLab URL`);
+    const token = process.env.GITLAB_TOKEN || credentialToken(parsed.host);
+    if (!token) {
+        throw new Error(`gitlab: no token for ${parsed.host} — set GITLAB_TOKEN, or store a PAT in git's credential store:\n` +
+            `  printf "protocol=https\\nhost=${parsed.host}\\nusername=<user>\\npassword=<token>\\n\\n" | git credential approve`);
+    }
+    ctx = { ...parsed, token };
+    return ctx;
+}
+export function parseRemote(remote) {
+    let m = remote.match(/^(https?:\/\/[^/]+)\/(.+?)(?:\.git)?\/?$/);
+    if (m)
+        return { base: m[1], host: m[1].replace(/^https?:\/\//, ''), project: m[2] };
+    m = remote.match(/^(?:ssh:\/\/)?[\w.-]+@([\w.-]+)(?::\d+)?[:/](.+?)(?:\.git)?\/?$/);
+    if (m)
+        return { base: `https://${m[1]}`, host: m[1], project: m[2] };
+    return null;
+}
+function credentialToken(host) {
+    try {
+        const out = execFileSync('git', ['credential', 'fill'], {
+            input: `protocol=https\nhost=${host}\n\n`,
+            encoding: 'utf8',
+            env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_ASKPASS: 'true' },
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+        return out.match(/^password=(.+)$/m)?.[1] ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+async function api(path, init) {
+    const { base, project, token } = gitlabCtx();
+    const sep = path.includes('?') ? '&' : '?';
+    const url = `${base}/api/v4/projects/${encodeURIComponent(project)}/${path}${init?.method ? '' : `${sep}per_page=100`}`;
+    const res = await fetch(url, {
+        ...init,
+        headers: { 'PRIVATE-TOKEN': token, 'content-type': 'application/json', ...init?.headers },
+    });
+    if (!res.ok)
+        throw new Error(`gitlab: ${init?.method ?? 'GET'} ${path} → ${res.status} ${(await res.text()).slice(0, 300)}`);
+    return (await res.json());
+}
+// GitLab's API has no bounded list query; stop at a short page and cap the walk.
+async function paged(path) {
+    const sep = path.includes('?') ? '&' : '?';
+    const out = [];
+    for (let page = 1; page <= 20; page++) {
+        const rows = await api(`${path}${sep}page=${page}`);
+        out.push(...rows);
+        if (rows.length < 100)
+            break;
+    }
+    return out;
+}
+async function toIssue(r) {
+    return {
+        number: r.iid,
+        title: r.title,
+        body: r.description ?? '',
+        url: r.web_url,
+        state: normalizeState(r.state),
+        labels: forgeLabels(r.labels),
+        author: r.author?.username ?? '',
+        createdAt: r.created_at ?? '',
+        comments: r.user_notes_count > 0 ? await listNotes(r.iid) : [],
+    };
+}
+function forgeLabels(labels) {
+    return (labels ?? []).flatMap((label) => {
+        const name = typeof label === 'string' ? label : label.name ?? '';
+        if (!name)
+            return [];
+        if (typeof label === 'string')
+            return [{ name }];
+        return [{ name, ...(label.color ? { color: label.color } : {}), ...(label.text_color ? { textColor: label.text_color } : {}) }];
+    });
+}
+function normalizeState(state) {
+    const s = (state || '').toLowerCase();
+    return s === 'opened' ? 'open' : s;
+}
+async function listNotes(iid) {
+    const rows = await paged(`issues/${iid}/notes`);
+    return rows
+        .filter((n) => !n.system)
+        .map((n) => ({ author: n.author?.username ?? '', createdAt: n.created_at ?? '', body: n.body ?? '' }));
+}
+export const gitlabDriver = {
+    host: 'gitlab',
+    async listIssues() {
+        const rows = await paged('issues?state=all&with_labels_details=true');
+        return Promise.all(rows.map(toIssue));
+    },
+    async listIssuesSince(sinceISO) {
+        const rows = await paged(`issues?state=all&with_labels_details=true&updated_after=${encodeURIComponent(sinceISO)}`);
+        return Promise.all(rows.map(toIssue));
+    },
+    async listPRs() {
+        const rows = await paged('merge_requests?state=opened');
+        return Promise.all(rows.map(async (r) => ({
+            number: r.iid,
+            title: r.title,
+            url: r.web_url,
+            state: normalizeState(r.state),
+            headRefName: r.source_branch,
+            closesIssues: (await paged(`merge_requests/${r.iid}/closes_issues`)).map((i) => i.iid),
+        })));
+    },
+    async createIssue({ title, body }) {
+        const r = await api('issues', {
+            method: 'POST',
+            body: JSON.stringify({ title, description: body }),
+        });
+        if (!r.web_url?.startsWith('http') || !Number.isFinite(r.iid))
+            throw new Error(`gitlab: issue create returned an unexpected result: ${JSON.stringify(r)}`);
+        return { number: r.iid, url: r.web_url };
+    },
+    async createComment({ number, body }) {
+        const { base, project } = gitlabCtx();
+        const r = await api(`issues/${number}/notes`, { method: 'POST', body: JSON.stringify({ body }) });
+        if (!Number.isFinite(r.id))
+            throw new Error(`gitlab: note create returned an unexpected result: ${JSON.stringify(r)}`);
+        return { url: `${base}/${project}/-/issues/${number}#note_${r.id}` };
+    },
+    async closeIssue({ number }) {
+        const r = await api(`issues/${number}`, {
+            method: 'PUT',
+            body: JSON.stringify({ state_event: 'close' }),
+        });
+        if (!r.web_url?.startsWith('http'))
+            throw new Error(`gitlab: issue close returned an unexpected result: ${JSON.stringify(r)}`);
+        return { url: r.web_url };
+    },
+};

package/node_modules/@spexcode/spec-forge/dist/drivers.d.ts

@@ -0,0 +1,10 @@
+import type { ForgeDriver } from './port.js';
+export declare const FORGE_DRIVERS: ForgeDriver[];
+export declare const DEFAULT_FORGE_HOST = "github";
+export declare function forgeDriverFor(host: string): ForgeDriver | undefined;
+export declare function forgeIssueStores(): {
+    id: string;
+    label: string;
+    kind: 'forge';
+}[];
+export declare function resolveForgeHost(): string;

package/node_modules/@spexcode/spec-forge/dist/drivers.js

@@ -0,0 +1,83 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { githubDriver } from './drivers/github.js';
+import { gitlabDriver } from './drivers/gitlab.js';
+export const FORGE_DRIVERS = [githubDriver, gitlabDriver];
+export const DEFAULT_FORGE_HOST = 'github';
+export function forgeDriverFor(host) {
+    return FORGE_DRIVERS.find((d) => d.host === host);
+}
+export function forgeIssueStores() {
+    const driver = forgeDriverFor(resolveForgeHost());
+    return driver ? [{ id: driver.host, label: driver.host, kind: 'forge' }] : [];
+}
+function gitEnv() {
+    const env = { ...process.env };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    delete env.GIT_INDEX_FILE;
+    delete env.GIT_OBJECT_DIRECTORY;
+    return env;
+}
+function gitOut(args) {
+    try {
+        return execFileSync('git', args, { env: gitEnv(), encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function configuredHost() {
+    const root = gitOut(['rev-parse', '--show-toplevel']);
+    if (!root)
+        return null;
+    for (const name of ['spexcode.local.json', 'spexcode.json']) {
+        const p = join(root, name);
+        if (!existsSync(p))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(p, 'utf8'));
+        }
+        catch (e) {
+            throw new Error(`${p} is not valid JSON: ${e.message}`);
+        }
+        const host = parsed?.forge?.host;
+        if (typeof host === 'string' && host.trim())
+            return host.trim();
+    }
+    return null;
+}
+function remoteHostname(url) {
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
+        try {
+            return new URL(url).hostname || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    const scp = /^(?:[^@\s/]+@)?([^:/\s]+):./.exec(url);
+    return scp ? scp[1] : null;
+}
+function hostFor(hostname) {
+    const h = hostname.toLowerCase();
+    if (h.includes('github'))
+        return 'github';
+    if (h.includes('bitbucket'))
+        return 'bitbucket';
+    return 'gitlab';
+}
+let cached = null;
+const RESOLVE_TTL_MS = 30_000;
+export function resolveForgeHost() {
+    const now = Date.now();
+    if (cached && now - cached.at < RESOLVE_TTL_MS)
+        return cached.host;
+    const url = gitOut(['remote', 'get-url', 'origin']);
+    const hostname = url ? remoteHostname(url) : null;
+    const host = configuredHost() ?? (hostname ? hostFor(hostname) : DEFAULT_FORGE_HOST);
+    cached = { host, at: now };
+    return host;
+}

package/node_modules/@spexcode/spec-forge/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './port.js';
+export * from './links.js';
+export * from './drivers.js';
+export * from './resident.js';

package/node_modules/@spexcode/spec-forge/dist/index.js

@@ -0,0 +1,4 @@
+export * from './port.js';
+export * from './links.js';
+export * from './drivers.js';
+export * from './resident.js';

package/node_modules/@spexcode/spec-forge/dist/links.d.ts

@@ -0,0 +1,15 @@
+import type { ForgeIssue, ForgePR } from './port.js';
+export type LinkedIssue = ForgeIssue & {
+    via: 'marker' | 'pr';
+};
+export type LinkedPR = ForgePR & {
+    via: 'branch';
+};
+export type NodeLinks = {
+    node: string;
+    issues: LinkedIssue[];
+    prs: LinkedPR[];
+};
+export declare function parseSpecMarkers(body: string): string[];
+export declare function branchToNode(branch: string, nodeIds: string[]): string | null;
+export declare function resolveLinks(issues: ForgeIssue[], prs: ForgePR[], nodeIds: string[]): NodeLinks[];

package/node_modules/@spexcode/spec-forge/dist/links.js

@@ -0,0 +1,65 @@
+export function parseSpecMarkers(body) {
+    const ids = [];
+    for (const m of (body || '').matchAll(/^\s*spec:\s*(.+)$/gim)) {
+        for (const part of m[1].split(',')) {
+            const id = part.trim();
+            if (id)
+                ids.push(id);
+        }
+    }
+    return ids;
+}
+export function branchToNode(branch, nodeIds) {
+    if (!branch?.startsWith('node/'))
+        return null;
+    const rest = branch.slice('node/'.length);
+    let best = null;
+    for (const id of nodeIds) {
+        if (rest === id || rest.startsWith(id + '-')) {
+            if (!best || id.length > best.length)
+                best = id;
+        }
+    }
+    return best;
+}
+export function resolveLinks(issues, prs, nodeIds) {
+    const known = new Set(nodeIds);
+    const byNode = new Map();
+    const slot = (node) => {
+        let s = byNode.get(node);
+        if (!s) {
+            s = { issues: new Map(), prs: new Map() };
+            byNode.set(node, s);
+        }
+        return s;
+    };
+    const prNode = new Map();
+    for (const pr of prs) {
+        const node = branchToNode(pr.headRefName, nodeIds);
+        if (!node)
+            continue;
+        prNode.set(pr.number, node);
+        slot(node).prs.set(pr.number, { ...pr, via: 'branch' });
+    }
+    const issueByNumber = new Map(issues.map((i) => [i.number, i]));
+    for (const issue of issues) {
+        for (const id of parseSpecMarkers(issue.body)) {
+            if (known.has(id))
+                slot(id).issues.set(issue.number, { ...issue, via: 'marker' });
+        }
+    }
+    for (const pr of prs) {
+        const node = prNode.get(pr.number);
+        if (!node)
+            continue;
+        for (const num of pr.closesIssues) {
+            const issue = issueByNumber.get(num);
+            if (issue && !slot(node).issues.has(num)) {
+                slot(node).issues.set(num, { ...issue, via: 'pr' });
+            }
+        }
+    }
+    return [...byNode.entries()]
+        .map(([node, s]) => ({ node, issues: [...s.issues.values()], prs: [...s.prs.values()] }))
+        .sort((a, b) => a.node.localeCompare(b.node));
+}

package/node_modules/@spexcode/spec-forge/dist/needs-eval.d.ts

@@ -0,0 +1,10 @@
+import type { ForgeIssue, ForgePR } from './port.js';
+import { type LinkedIssue } from './links.js';
+export declare const NEEDS_EVAL = "needs-eval";
+export declare function isNeedsEval(issue: ForgeIssue): boolean;
+export type EvalPending = LinkedIssue;
+export type NodeEvalPending = {
+    node: string;
+    pending: EvalPending[];
+};
+export declare function resolveEvalPending(issues: ForgeIssue[], prs: ForgePR[], nodeIds: string[]): NodeEvalPending[];

package/node_modules/@spexcode/spec-forge/dist/needs-eval.js

@@ -0,0 +1,20 @@
+import { resolveLinks } from './links.js';
+export const NEEDS_EVAL = 'needs-eval';
+const BODY_MARKER = new RegExp(`^\\s*${NEEDS_EVAL}\\s*:?\\s*$`, 'im');
+export function isNeedsEval(issue) {
+    if (issue.labels.some((l) => l.name.trim().toLowerCase() === NEEDS_EVAL))
+        return true;
+    return BODY_MARKER.test(issue.body || '');
+}
+export function resolveEvalPending(issues, prs, nodeIds) {
+    const flagged = new Set(issues.filter(isNeedsEval).map((i) => i.number));
+    if (!flagged.size)
+        return [];
+    const out = [];
+    for (const { node, issues: linked } of resolveLinks(issues, prs, nodeIds)) {
+        const pending = linked.filter((i) => i.state === 'open' && flagged.has(i.number));
+        if (pending.length)
+            out.push({ node, pending });
+    }
+    return out;
+}

package/node_modules/@spexcode/spec-forge/dist/port.d.ts

@@ -0,0 +1,53 @@
+export type ForgeComment = {
+    author: string;
+    createdAt: string;
+    body: string;
+};
+export type ForgeLabel = {
+    name: string;
+    color?: string;
+    textColor?: string;
+};
+export type ForgeIssue = {
+    number: number;
+    title: string;
+    body: string;
+    url: string;
+    state: string;
+    labels: ForgeLabel[];
+    author: string;
+    createdAt: string;
+    comments: ForgeComment[];
+};
+export type ForgePR = {
+    number: number;
+    title: string;
+    url: string;
+    state: string;
+    headRefName: string;
+    closesIssues: number[];
+};
+export interface ForgeDriver {
+    readonly host: string;
+    listIssues(): Promise<ForgeIssue[]>;
+    listPRs(): Promise<ForgePR[]>;
+    createIssue(input: {
+        title: string;
+        body: string;
+    }): Promise<{
+        number: number;
+        url: string;
+    }>;
+    createComment(input: {
+        number: number;
+        body: string;
+    }): Promise<{
+        url: string;
+    }>;
+    closeIssue(input: {
+        number: number;
+    }): Promise<{
+        url: string;
+    }>;
+    listIssuesSince?(sinceISO: string): Promise<ForgeIssue[]>;
+}

package/node_modules/@spexcode/spec-forge/dist/port.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@spexcode/spec-forge/dist/resident.d.ts

@@ -0,0 +1,7 @@
+import type { ForgeIssue, ForgePR } from './port.js';
+export declare function residentForgeState(): {
+    issues: ForgeIssue[];
+    prs: ForgePR[];
+};
+export declare function residentForgeRevision(): number;
+export declare function refreshForgeNow(): Promise<void>;

package/node_modules/@spexcode/spec-forge/dist/resident.js

@@ -0,0 +1,43 @@
+import { ForgeCache } from './cache.js';
+import { forgeDriverFor, resolveForgeHost } from './drivers.js';
+const cache = new ForgeCache();
+let inFlight = null;
+let lastAttempt = 0;
+const TTL_MS = 20_000;
+let lastIssueSync = null;
+let lastFull = 0;
+const FULL_MS = 30 * 60_000;
+function refreshIfStale(now) {
+    if (inFlight || (lastAttempt && now - lastAttempt < TTL_MS))
+        return;
+    const driver = forgeDriverFor(resolveForgeHost());
+    if (!driver)
+        return;
+    lastAttempt = now;
+    const startISO = new Date(now).toISOString(); // stamped at fetch START so an update during the fetch lands in the next window
+    const incremental = lastIssueSync && driver.listIssuesSince && now - lastFull < FULL_MS;
+    inFlight = (incremental
+        ? Promise.all([
+            driver.listIssuesSince(lastIssueSync).then((delta) => cache.applyIssues(delta)),
+            driver.listPRs().then((prs) => cache.setPRs(prs)),
+        ]).then(() => { lastIssueSync = startISO; })
+        : cache.reconcile(driver).then(() => { lastFull = now; lastIssueSync = startISO; }))
+        .catch(() => { })
+        .finally(() => { inFlight = null; });
+}
+export function residentForgeState() {
+    refreshIfStale(Date.now());
+    return cache.state();
+}
+export function residentForgeRevision() {
+    return cache.stateRevision();
+}
+export async function refreshForgeNow() {
+    if (inFlight)
+        await inFlight;
+    lastAttempt = 0;
+    lastFull = 0;
+    refreshIfStale(Date.now());
+    if (inFlight)
+        await inFlight;
+}

package/node_modules/@spexcode/spec-forge/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@spexcode/spec-forge",
+  "version": "0.6.6",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./port": "./dist/port.js",
+    "./links": "./dist/links.js",
+    "./drivers": "./dist/drivers.js",
+    "./resident": "./dist/resident.js",
+    "./cli": "./dist/cli.js",
+    "./package.json": "./package.json"
+  },
+  "files": ["dist"],
+  "description": "Host-agnostic forge link tracer — reads a forge's open issues/PRs and resolves each to the spec node it serves (issue-body `Spec: <id>` marker + `node/<id>` PR branch). Read-only; a node's status stays git-derived.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node ../scripts/build-dist.mjs",
+    "prepublishOnly": "node ../scripts/release-publish.mjs --from-package-publish",
+    "test": "tsx --test src/*.test.ts"
+  },
+  "dependencies": {
+    "@spexcode/spec-core": "0.6.6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.16.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}

package/package.json

@@ -1,42 +1,47 @@
 {
   "name": "spexcode",
-  "version": "0.6.2",
+  "version": "0.6.6",
   "type": "module",
   "description": "SpexCode — a spec-driven, self-developing dev tool. The `spex` CLI + spec server reads the .spec tree and its git history, and serves the dashboard.",
   "license": "MIT",
   "bin": {
-    "spex": "spec-cli/bin/spex.mjs"
+    "spex": "bin/spex.mjs"
   },
+  "workspaces": [
+    "packages/*",
+    "spec-cli",
+    "spec-eval",
+    "spec-forge",
+    "spec-dashboard"
+  ],
   "files": [
-    "spec-cli/src",
-    "!spec-cli/src/**/*.test.ts",
-    "spec-cli/bin",
-    "spec-cli/templates",
-    "spec-cli/hooks",
-    "spec-eval/src",
-    "!spec-eval/src/**/*.test.ts",
-    "spec-forge/src",
-    "!spec-forge/src/**/*.test.ts",
-    "spec-dashboard/dist",
-    "spec-dashboard/src/reviewFilters.js",
-    "spec-dashboard/src/reviewQuery.js",
-    "spec-dashboard/src/session.js",
-    "README.md"
+    "bin"
   ],
   "engines": {
     "node": ">=22"
   },
   "scripts": {
-    "api": "cd spec-cli && npm run serve",
+    "build": "npm run build --workspace=@spexcode/spec-core && npm run build --workspace=@spexcode/session-core && npm run build --workspace=@spexcode/spec-eval && npm run build --workspace=@spexcode/spec-forge && npm run build --workspace=@spexcode/spec-cli",
+    "api": "npm run build && node bin/spex.mjs serve",
     "web": "cd spec-dashboard && npm run dev",
+    "build:public": "node scripts/public-graph-build.mjs",
+    "test:public-graph": "npm run build:public && node spec-dashboard/test/public-graph-static.e2e.mjs",
     "lint": "node scripts/sync-init-plugins.mjs --check && cd spec-cli && npm run -s lint",
     "sync:init-plugins": "node scripts/sync-init-plugins.mjs --write",
     "test:init-plugins": "node --test scripts/sync-init-plugins.test.mjs",
+    "test:release-publish": "node --test scripts/release-publish.test.mjs",
+    "release:check": "node scripts/release-publish.mjs",
+    "release:publish": "node scripts/release-publish.mjs --publish",
+    "prepublishOnly": "node scripts/release-publish.mjs --from-package-publish",
+    "test:docs-release": "node --test scripts/docs-release.test.mjs scripts/reference-snapshot.test.mjs",
     "hooks": "bash scripts/install-hooks.sh",
     "prepack": "node scripts/sync-init-plugins.mjs --check && node scripts/prepack.mjs"
   },
   "dependencies": {
-    "tsx": "^4.19.2"
+    "@spexcode/spec-cli": "0.6.6"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "optionalDependencies": {
     "@hono/node-server": "^1.13.7",
@@ -47,5 +52,14 @@
   "devDependencies": {
     "@types/node": "^20.16.0",
     "typescript": "^5.6.3"
-  }
+  },
+  "bundleDependencies": [
+    "@spexcode/spec-cli"
+  ],
+  "main": "index.js",
+  "directories": {
+    "doc": "docs"
+  },
+  "keywords": [],
+  "author": ""
 }

package/spec-cli/bin/spex.mjs

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-// @@@ spex launcher - this repo has no build step, so the installed `spex` bin shells to tsx to
-// run the TypeScript CLI directly. After `npm link` (or a global install) `spex lint` works anywhere.
-import { spawn } from 'node:child_process'
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-// @@@ self-contained - resolve tsx + cli from THIS package, not the cwd. A fresh worktree off main has
-// no node_modules, so `npx tsx` there would try to install; using the package's own tsx makes a global
-// `spex` work from any cwd (agents, git hooks) against this package's code, operating on the cwd.
-const pkg = join(dirname(fileURLToPath(import.meta.url)), '..') // spec-cli/
-const cli = join(pkg, 'src', 'cli.ts')
-
-// @@@ mid-merge guard - no build step means every spex call parses this package's live TypeScript, so
-// while a merge conflict is being resolved in the checkout that hosts it, the source holds conflict
-// markers and tsx dies with a raw esbuild stacktrace — on EVERY call, including the Stop hook and an
-// agent's `spex session done`. Catch that one transient state up front: scan the source trees the CLI
-// imports (spec-cli ←→ spec-eval ←→ spec-forge), and if any file carries a marker, print one actionable
-// line and exit 75 (EX_TEMPFAIL: transient, retry) instead of spawning tsx into the stacktrace.
-const srcRoots = [join(pkg, 'src'), join(pkg, '..', 'spec-eval', 'src'), join(pkg, '..', 'spec-forge', 'src')]
-const conflicted = srcRoots.flatMap((root) => {
-  if (!existsSync(root)) return []
-  return readdirSync(root, { recursive: true })
-    .filter((f) => /\.(ts|tsx|js|mjs)$/.test(String(f)))
-    .map((f) => join(root, String(f)))
-    .filter((path) => {
-      try { return /^<{7} /m.test(readFileSync(path, 'utf8')) } catch { return false }
-    })
-})
-if (conflicted.length) {
-  console.error('spex: paused mid-merge — unresolved conflict markers in the source spex runs:')
-  for (const f of conflicted) console.error(`  ${f}`)
-  console.error('spex executes this TypeScript directly (no build step); resolve the merge, then retry. (exit 75)')
-  process.exit(75)
-}
-// @@@ cross-platform tsx resolution ([[platform-support]]) - resolve tsx's JS ENTRY (dist/cli.mjs) with
-// Node's own resolver from spec-cli, then run it through THIS node binary (process.execPath). tsx may live
-// in spec-cli/node_modules (dev) or be hoisted above the installed `spexcode` package (a real consumer
-// project) — one resolver covers both without hardcoded consumer paths. We deliberately never spawn the
-// `.bin/tsx` shim, nor a `.mjs` directly: on Windows the shim is an extensionless sh script and the `.mjs`
-// leans on a shebang, neither of which `child_process.spawn` can execute — that is the #37 crash
-// (`spawn …\node_modules\.bin\tsx ENOENT`) of `spex init`. `node dist/cli.mjs …` is shell-free and identical
-// on every OS.
-function resolveTsxCli() {
-  try {
-    const req = createRequire(join(pkg, 'package.json'))
-    return join(dirname(req.resolve('tsx/package.json')), 'dist', 'cli.mjs')
-  } catch {
-    console.error('spex: cannot find the `tsx` runtime this package needs — run `npm install` in the SpexCode package, then retry.')
-    process.exit(69)
-  }
-}
-const tsxCli = resolveTsxCli()
-const args = process.argv.slice(2)
-const env = { ...process.env }
-// A backend/dashboard is a project or host control plane, never the managed session that happened to start
-// it. Scrub before tsx starts: doing this inside cli.ts is too late because tsx's resident esbuild helper has
-// already inherited the caller. New session launches provide the adapter-registry-derived key manifest; the
-// fallback covers sessions created before that manifest existed.
-if (args[0] === 'serve' || args[0] === 'dashboard') {
-  const identityKeys = (env.SPEXCODE_SESSION_IDENTITY_VARS
-    || 'SPEXCODE_SESSION_ID,CLAUDE_CODE_SESSION_ID,CODEX_THREAD_ID,OPENCODE_SESSION_ID,PI_SESSION_ID')
-    .split(',').map((key) => key.trim()).filter(Boolean)
-  for (const key of identityKeys) delete env[key]
-}
-spawn(process.execPath, [tsxCli, cli, ...args], { stdio: 'inherit', env })
-  .on('exit', (code) => process.exit(code ?? 0))