codehere 1.0.1 → 1.0.2

package/dist/infrastructure/protocols/mcp-tools.js

@@ -1,401 +0,0 @@
-// MCP tool layer extracted from mcp-server-impl.ts (god-file split, 2026-06-29).
-// The JSON-RPC surface: tool definitions + the read-only handlers + the dispatcher.
-// The HTTP daemon (startMCPServer) stays in mcp-server-impl.ts and imports dispatch+TOOLS.
-import { existsSync, readFileSync } from 'fs';
-import { relative, resolve as resolvePath, sep } from 'path';
-import { computeSpendToday } from '../cost/spend-aggregator.js';
-import { loadBudget, budgetUsedPct } from '../cost/budget-config.js';
-import { loadTeamConfig, writeMyShare, buildTeamView } from '../cost/team-ledger.js';
-import { collectFilesForMCP, scoreFileForMCP, aggregateTrust } from './mcp-helpers.js';
-import { scanPayload, calculateRiskScore, AUDIT_FILE, verifyAuditChain } from '../hooks/claude-sdk-hook.js';
-import { getVersion } from '../../utils/version.js';
-// ── Tool definitions ─────────────────────────────────────────────────────────
-// Tool annotations follow the MCP spec (the github/github-mcp-server pattern:
-// toolsets + an explicit read-only declaration). Every codehere MCP tool is
-// ANALYSIS-ONLY — none writes files, spawns agents, or mutates state — and the
-// annotations SAY so at the protocol level (readOnlyHint), so a cautious client
-// can mount codehere's MCP knowing the whole surface is inspect-only. The
-// 'toolset' grouping mirrors gh-mcp's toolset concept (security · audit).
-// NOTE: readOnlyHint/title are MCP-spec (rev 2025-03-26) fields — we still
-// declare protocolVersion 2024-11-05, where clients ignore unknown fields, so
-// this is additive; 'toolset' is a CUSTOM extension (gh-mcp's toolsets are a
-// server-side flag, not a wire field) and annotations are self-declarations,
-// not proofs. If a WRITE tool is ever added, it must carry readOnlyHint:false
-// + its own destructiveHint — and the README line "Exposes 4 read-only tools"
-// (README.md §MCP) must change in the same commit (binding honesty rule).
-export const TOOLS = [
-    {
-        name: 'codehere_trust',
-        annotations: { title: 'Trust-score a file or snippet', readOnlyHint: true, toolset: 'security' },
-        description: 'Scan a file or code snippet for security vulnerabilities. Returns a trust score 0-100, grade, and plain-English findings. Zero API calls — runs entirely locally.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filepath: { type: 'string', description: 'Path to file (relative to cwd)' },
-                code: { type: 'string', description: 'Code content to scan (alternative to filepath)' },
-                verbose: { type: 'boolean', description: 'Include all findings with line numbers' },
-            },
-        },
-    },
-    {
-        name: 'codehere_scan',
-        annotations: { title: 'Scan text for prompt-injection / threats', readOnlyHint: true, toolset: 'security' },
-        description: 'Scan an instruction, prompt, or command text for injection attacks, credential theft attempts, destructive operations, and other threats. Returns block/allow decision with findings.',
-        inputSchema: {
-            type: 'object',
-            required: ['text'],
-            properties: {
-                text: { type: 'string', description: 'Text to scan (instruction, prompt, command)' },
-            },
-        },
-    },
-    {
-        name: 'codehere_review',
-        annotations: { title: 'Review a directory, rank riskiest files', readOnlyHint: true, toolset: 'security' },
-        description: 'Review all files in a directory and return trust scores. Identifies the riskiest files to focus review effort.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Directory path (default: current directory)' },
-                topN: { type: 'number', description: 'Return top N riskiest files (default: 10)' },
-            },
-        },
-    },
-    {
-        name: 'codehere_audit',
-        annotations: { title: 'Read / verify the hash-chained audit log', readOnlyHint: true, toolset: 'audit' },
-        description: 'Read recent hook audit log entries — shows which tool calls codehere blocked, allowed, or overrode (fail-open paths) in Claude Code sessions. Pass verify:true to instead validate the SHA-256 hash chain and return any tampering detected.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'number', description: 'Number of recent entries to return (default: 20)' },
-                blockedOnly: { type: 'boolean', description: 'Only return blocked events' },
-                overrideOnly: {
-                    type: 'boolean',
-                    description: 'Only return trust-override events — cases where the scanner was bypassed (stdin failure, parse failure, --log-only, scan exception). Per CC frontier Q1 (auditable permission trails) — surface every bypass for review.',
-                },
-                verify: {
-                    type: 'boolean',
-                    description: 'Verify the SHA-256 hash chain instead of returning entries. Returns { valid, totalEntries, chainedEntries, legacyEntries, errors[] } where errors lists every detected tampering point (modification / deletion / insertion / parse failure). Per CC frontier Q1 (cryptographic commitment + tamper evidence).',
-                },
-            },
-        },
-    },
-    {
-        name: 'codehere_spend',
-        annotations: { title: "Today's estimated spend by agent and project", readOnlyHint: true, toolset: 'cost' },
-        description: "Today's estimated coding-agent spend on this machine, broken down by agent and project, against the daily budget. So you can answer 'what have we spent today' from inside the session. Estimate from real token counts at published rates, not a provider invoice.",
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'codehere_team',
-        annotations: { title: 'Merged team cost + record across machines', readOnlyHint: true, toolset: 'cost' },
-        description: "The team's merged cost and integrity-checked record across every machine that shares the team git repo (spend by machine, total recorded actions, any broken audit chains). Falls back to this machine's solo view when no team is configured. Pass strict:true to REFUSE a total when any share is tampered or its audit chain is broken, instead of reporting a number that can't be trusted.",
-        inputSchema: {
-            type: 'object',
-            properties: {
-                strict: {
-                    type: 'boolean',
-                    description: 'When true, if any share is tampered or its audit chain is broken, return a refusal naming the untrustworthy machines instead of a team total.',
-                },
-            },
-        },
-    },
-];
-/** codehere_spend MCP tool: today's estimated spend, structured numbers plus a
- *  one-line summary the agent can quote. Reads local state only. */
-function handleSpend(_params) {
-    const s = computeSpendToday();
-    const cfg = loadBudget();
-    const fmt = (n) => '$' + (Number(n) || 0).toFixed(2);
-    const pct = budgetUsedPct(s.totalUsd, cfg);
-    const head = cfg.dailyUsd != null
-        ? `codehere spend today: ${fmt(s.totalUsd)} of ${fmt(cfg.dailyUsd)} daily budget (${pct ?? 0}% used), across ${s.sessionCount} session${s.sessionCount === 1 ? '' : 's'}.`
-        : `codehere spend today: ${fmt(s.totalUsd)} across ${s.sessionCount} session${s.sessionCount === 1 ? '' : 's'}, no budget set.`;
-    const agents = Object.entries(s.byAgent || {})
-        .map(([a, v]) => `  ${a}: ${fmt(v.usd)} (${v.sessions} session${v.sessions === 1 ? '' : 's'})`)
-        .join('\n') || '  (no agent spend today)';
-    const projects = Object.entries(s.byProject || {})
-        .map(([p, v]) => `  ${p}: ${fmt(v.usd)}`)
-        .join('\n') || '  (no project spend today)';
-    const raw = JSON.stringify({
-        totalUsd: s.totalUsd,
-        sessionCount: s.sessionCount,
-        dailyBudgetUsd: cfg.dailyUsd,
-        pctUsed: pct,
-        byAgent: s.byAgent,
-        byProject: s.byProject,
-        tokens: s.tokens,
-    });
-    return `${head}\nEstimate from real token counts at published rates, not a provider invoice.\n\nBy agent:\n${agents}\n\nBy project:\n${projects}\n\nRaw: ${raw}`;
-}
-/** codehere_team MCP tool: the merged team view, or this machine's solo view when
- *  no team git repo is configured. Reads local + the team dir only. */
-function handleTeam(_params) {
-    const strict = Boolean(_params?.strict);
-    const fmt = (n) => '$' + (Number(n) || 0).toFixed(2);
-    const cfg = loadTeamConfig();
-    if (!cfg.dir) {
-        const s = computeSpendToday();
-        return `No team configured. This machine today: ${fmt(s.totalUsd)} across ${s.sessionCount} session${s.sessionCount === 1 ? '' : 's'}. Run "codehere team set-dir <a git repo>" on each machine to merge the whole team, local-first.`;
-    }
-    try {
-        writeMyShare(cfg.dir);
-    }
-    catch {
-        /* dir not writable; still read what is there */
-    }
-    const v = buildTeamView(cfg.dir, cfg.dailyUsd);
-    const count = (v.machines || []).length;
-    const machines = (v.machines || []).map((m) => `  ${m.machineId}: ${fmt(m.totalUsd)}`).join('\n') || '  (none)';
-    const agents = Object.entries(v.perAgent || {}).sort((a, b) => b[1] - a[1]);
-    const byAgent = agents.length
-        ? '\n\nBy agent (cost · what each did):\n' +
-            agents
-                .map(([a, usd]) => {
-                const s = v.perAgentSessions?.[a] ?? 0;
-                return `  ${a}: ${fmt(usd)} · ${s} session${s === 1 ? '' : 's'}`;
-            })
-                .join('\n')
-        : '';
-    const broken = v.brokenChains || [];
-    const brokenLine = broken.length
-        ? `\nBROKEN audit chain on: ${broken.join(', ')}. Investigate before trusting that record.`
-        : '';
-    const tampered = v.tamperedShares || [];
-    const unsigned = v.unsignedShares || [];
-    const sigLine = tampered.length
-        ? `\nSIGNATURE INVALID on: ${tampered.join(', ')} — that share was altered or re-signed with a different key than first seen. Do not trust it.`
-        : count
-            ? `\nAll shares signed; keys match the ones first seen (no post-write change detected).`
-            : '';
-    const unsignedLine = unsigned.length ? `\nUnsigned, can't verify: ${unsigned.join(', ')}.` : '';
-    if (strict) {
-        const bad = [...new Set([...tampered, ...broken])];
-        if (bad.length) {
-            return `REFUSED (strict): the team record can't be trusted — ${bad.join(', ')} ${bad.length === 1 ? 'is' : 'are'} tampered or ${bad.length === 1 ? 'has' : 'have'} a broken audit chain. Not reporting a total. Investigate that machine's share before trusting the record.\n\nRaw: ${JSON.stringify({ strict: true, ok: false, untrustworthy: bad, tamperedShares: tampered, brokenChains: broken })}`;
-        }
-    }
-    const head = `codehere team today: ${fmt(v.teamTotal)}${v.dailyUsd != null ? ` of ${fmt(v.dailyUsd)} team budget` : ''} across ${count} machine${count === 1 ? '' : 's'}, ${(v.totalActions || 0).toLocaleString()} recorded actions.`;
-    const practiceLine = v.practice && v.practice.sessions > 0
-        ? `\nPractice runs: ${v.practice.sessions} session${v.practice.sessions === 1 ? '' : 's'} · ${fmt(v.practice.usd)} fabricated · not in the totals.`
-        : '';
-    return `${head}\nEstimate from real tokens at published rates, not a provider invoice.${practiceLine}${brokenLine}${sigLine}${unsignedLine}\n\nBy machine:\n${machines}${byAgent}\n\nRaw: ${JSON.stringify(v)}`;
-}
-function handleTrust(params) {
-    const { filepath, code, verbose } = params;
-    let content;
-    let label;
-    if (code) {
-        content = code;
-        label = 'provided code';
-    }
-    else if (filepath) {
-        // MED #31 (atomic audit) · scope the inspect-only trust tool to the cwd:
-        // '../../etc/passwd' walked out of the workspace. Read-only, so the
-        // blast radius was disclosure-shaped — still, the tool's contract says
-        // "scores YOUR project's file".
-        const resolved = resolvePath(process.cwd(), filepath);
-        if (resolved !== process.cwd() && !resolved.startsWith(process.cwd() + sep)) {
-            return JSON.stringify({ error: `Path escapes the workspace: ${filepath}` });
-        }
-        if (!existsSync(resolved)) {
-            return JSON.stringify({ error: `File not found: ${filepath}` });
-        }
-        content = readFileSync(resolved, 'utf-8');
-        label = filepath;
-    }
-    else {
-        return JSON.stringify({ error: 'Provide either filepath or code' });
-    }
-    const result = scoreFileForMCP(label, content);
-    if (!verbose) {
-        // Compact response
-        return JSON.stringify({
-            score: result.score,
-            grade: result.grade,
-            summary: result.summary,
-            criticalCount: result.findings.filter((f) => f.severity === 'critical').length,
-            highCount: result.findings.filter((f) => f.severity === 'high').length,
-            recommendation: result.score >= 75
-                ? 'Safe — minor issues can be addressed in follow-up'
-                : result.score >= 60
-                    ? 'Review recommended before merge'
-                    : 'Block — resolve critical/high findings first',
-        });
-    }
-    return JSON.stringify(result, null, 2);
-}
-function handleScan(params) {
-    const text = String(params.text ?? '');
-    const findings = scanPayload(text);
-    const riskScore = calculateRiskScore(findings);
-    const criticalFindings = findings.filter((f) => f.severity === 'critical');
-    const blocked = criticalFindings.length > 0 || riskScore >= 60;
-    return JSON.stringify({
-        blocked,
-        riskScore,
-        decision: blocked ? 'block' : 'allow',
-        reason: blocked
-            ? criticalFindings.length > 0
-                ? `${criticalFindings[0].category}: ${criticalFindings[0].description}`
-                : `Risk score ${riskScore}/100 exceeds threshold`
-            : 'No threats detected',
-        findings: findings.slice(0, 10), // cap at 10 to keep response small
-    });
-}
-/**
- * Coerce a client-supplied numeric param to a bounded integer. Daemon
- * endpoints take topN/limit straight from request bodies; a negative or NaN
- * value silently corrupts slice() math (limit=-1 → slice keeps all-but-last,
- * NaN → slice returns everything). Clamp to a sane range instead of trusting
- * the wire.
- */
-export function clampInt(v, def, min, max) {
-    // null/undefined = absent → default. Number(null) is 0 (finite), so without
-    // this guard a literal null would coerce to the min instead of the default.
-    if (v === null || v === undefined)
-        return def;
-    const n = Math.floor(Number(v));
-    if (!Number.isFinite(n))
-        return def;
-    return Math.max(min, Math.min(n, max));
-}
-function handleReview(params) {
-    const targetPath = String(params.path ?? process.cwd());
-    const topN = clampInt(params.topN, 10, 1, 100);
-    try {
-        const files = collectFilesForMCP(targetPath);
-        if (files.length === 0) {
-            return JSON.stringify({ message: 'No code files found', path: targetPath });
-        }
-        const results = files.map((f) => scoreFileForMCP(relative(targetPath, f.filepath), f.code));
-        results.sort((a, b) => a.score - b.score); // worst first
-        const top = results.slice(0, topN);
-        // Use the shared honesty floor (a critical finding caps the grade at F) so the
-        // MCP grade can never disagree with the CLI's grade for the same directory.
-        const { overallScore, grade } = aggregateTrust(results);
-        return JSON.stringify({
-            overallScore,
-            grade,
-            totalFiles: results.length,
-            riskiestFiles: top.map((r) => ({
-                filepath: r.filepath,
-                score: r.score,
-                grade: r.grade,
-                summary: r.summary,
-                criticalCount: r.findings.filter((f) => f.severity === 'critical').length,
-                highCount: r.findings.filter((f) => f.severity === 'high').length,
-            })),
-        });
-    }
-    catch (e) {
-        return JSON.stringify({ error: String(e) });
-    }
-}
-function handleAudit(params) {
-    const limit = clampInt(params.limit, 20, 1, 500);
-    const blockedOnly = Boolean(params.blockedOnly);
-    const overrideOnly = Boolean(params.overrideOnly);
-    const verify = Boolean(params.verify);
-    if (verify) {
-        // Tamper-evidence verification — walks the file, recomputes every hash,
-        // checks the chain. Returns full report including ALL break points.
-        const result = verifyAuditChain(AUDIT_FILE);
-        return JSON.stringify(result, null, 2);
-    }
-    if (!existsSync(AUDIT_FILE)) {
-        return JSON.stringify({
-            message: 'No audit log yet — install hooks first with: codehere hook install',
-            entries: [],
-        });
-    }
-    const lines = readFileSync(AUDIT_FILE, 'utf-8')
-        .split('\n')
-        .filter(Boolean)
-        .slice(-Math.min(limit * 3, 500)); // read more than needed to account for filter
-    const entries = lines
-        .map((l) => {
-        try {
-            return JSON.parse(l);
-        }
-        catch {
-            return null;
-        }
-    })
-        .filter(Boolean)
-        .filter((e) => {
-        if (overrideOnly)
-            return Boolean(e.overrideReason);
-        if (blockedOnly)
-            return Boolean(e.blocked);
-        return true;
-    })
-        .slice(-limit);
-    return JSON.stringify({ entries, total: entries.length });
-}
-// ── JSON-RPC dispatcher ──────────────────────────────────────────────────────
-export function dispatch(req) {
-    const id = req.id;
-    const params = (req.params ?? {});
-    try {
-        switch (req.method) {
-            case 'initialize': {
-                // Echo the client's requested protocol version so Streamable-HTTP
-                // clients (Codex on 2025-x) negotiate; fall back to the baseline.
-                const clientPv = typeof params.protocolVersion === 'string' ? params.protocolVersion : '2024-11-05';
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    result: {
-                        protocolVersion: clientPv,
-                        capabilities: { tools: {} },
-                        serverInfo: { name: 'codehere', version: getVersion() },
-                    },
-                };
-            }
-            case 'tools/list':
-                return { jsonrpc: '2.0', id, result: { tools: TOOLS } };
-            case 'tools/call': {
-                const toolName = String(params.name ?? '');
-                const toolParams = (params.arguments ?? {});
-                let content;
-                switch (toolName) {
-                    case 'codehere_trust':
-                        content = handleTrust(toolParams);
-                        break;
-                    case 'codehere_scan':
-                        content = handleScan(toolParams);
-                        break;
-                    case 'codehere_review':
-                        content = handleReview(toolParams);
-                        break;
-                    case 'codehere_audit':
-                        content = handleAudit(toolParams);
-                        break;
-                    case 'codehere_spend':
-                        content = handleSpend(toolParams);
-                        break;
-                    case 'codehere_team':
-                        content = handleTeam(toolParams);
-                        break;
-                    default:
-                        return { jsonrpc: '2.0', id, error: { code: -32601, message: `Unknown tool: ${toolName}` } };
-                }
-                return {
-                    jsonrpc: '2.0',
-                    id,
-                    result: { content: [{ type: 'text', text: content }] },
-                };
-            }
-            case 'ping':
-                return { jsonrpc: '2.0', id, result: {} };
-            default:
-                return { jsonrpc: '2.0', id, error: { code: -32601, message: `Method not found: ${req.method}` } };
-        }
-    }
-    catch (e) {
-        return { jsonrpc: '2.0', id, error: { code: -32603, message: String(e) } };
-    }
-}
-//# sourceMappingURL=mcp-tools.js.map

package/dist/infrastructure/protocols/probe-port.js

@@ -1,36 +0,0 @@
-/**
- * Detect whether a given host:port is already serving a codehere instance.
- *
- * Used by `codehere start` when the listen() fails with EADDRINUSE: we'd
- * rather give the user a friendly "codehere already running, opening browser"
- * than a Node stack trace. If something ELSE holds the port we tell them to
- * pick a different one.
- *
- * Approach: hit the existing server's /health endpoint. The codehere MCP
- * server returns a JSON body with `server: 'codehere-mcp'` — no other tool
- * uses that exact identifier. Generous 1.5-second timeout so a slow loopback
- * doesn't false-negative.
- */
-export async function isCodehereOnPort(host, port, timeoutMs = 1500) {
-    const ac = new AbortController();
-    const timer = setTimeout(() => ac.abort(), timeoutMs);
-    try {
-        const res = await fetch(`http://${host}:${port}/health`, { signal: ac.signal });
-        if (!res.ok)
-            return { isCodehere: false };
-        const body = (await res.json());
-        if (body?.server === 'codehere-mcp') {
-            return { isCodehere: true, version: body.version };
-        }
-        return { isCodehere: false };
-    }
-    catch {
-        // Connection refused, timeout, malformed response — anything that's not
-        // a positive codehere identification. Treat as "not codehere."
-        return { isCodehere: false };
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-//# sourceMappingURL=probe-port.js.map

package/dist/infrastructure/protocols/thread-phase.js

@@ -1,105 +0,0 @@
-/**
- * Thread phase classifier · the demo v12 lifecycle spine.
- *
- * A thread reads as a phased narrative (research → build → ship → audit → live).
- * Steps don't carry phase labels, so classify by the dominant signal in the
- * step LABEL (the output is noisy — agent names like "claude-code", file lists —
- * and misfires the keywords).
- *
- * This logic used to live inline in the ui-page-v2 template string, where it was
- * untestable — and a `\bcode\b` regex matched "claude-code" and mislabeled read
- * steps as BUILD (caught by eye, not a test). Extracted here so it's unit-tested,
- * and its SOURCE is injected back into the browser template via
- * PHASE_CLASSIFIER_SRC — one source of truth, not a duplicated twin.
- */
-export const PHASE_ORDER = ['research', 'build', 'ship', 'audit', 'live'];
-export const PHASE_META = {
-    research: { n: 1, label: 'research', done: 'research locked', verb: 'explored' },
-    build: { n: 2, label: 'build', done: 'build done', verb: 'built' },
-    ship: { n: 3, label: 'ship', done: 'shipped', verb: 'tested & shipped' },
-    audit: { n: 4, label: 'audit', done: 'audited', verb: 'reviewed' },
-    live: { n: 5, label: 'live', done: 'live', verb: 'recovered' },
-};
-// Classify on the LABEL only · keep keywords action-specific, NOT domain words.
-// "rate-limit" is a FEATURE many tasks build — it must NOT signal LIVE, or every
-// rate-limit task mislabels its build steps as live. "claude-code" must NOT
-// match \bcode\b → that was the original bug.
-export function stepPhase(step) {
-    const s = (step.label || '').toLowerCase();
-    if (/failover|crashed|recover|orphan|hydrat|checkpoint|fell back|failed over/.test(s))
-        return 'live';
-    if (/verif|audit|final report|trust grade|claim vs|w-?pass|write-pass|chain entry/.test(s))
-        return 'audit';
-    if (/\btest\b|\btests\b|\bpush\b|commit|deploy|benchmark|\bship\b|\bmerge\b/.test(s))
-        return 'ship';
-    if (/\bedit\b|\bwrite\b|writes |writing|implement|refactor|patch|\bbuild\b|dispatch/.test(s))
-        return 'build';
-    if (/pre-prompt|scan|\bread\b|grep|search|analyz|research|context|\broute|explor|\bmap\b/.test(s))
-        return 'research';
-    return null;
-}
-// Assign every step a phase · unknown steps inherit the running phase so the
-// timeline never fragments. Phases only ADVANCE, never regress — once a task has
-// shipped, a stray "read" stays in ship rather than yanking the narrative back.
-// The regress check is against the OLD running phase, THEN advance.
-export function classifySteps(steps) {
-    const out = [];
-    let cur = 'research';
-    for (let i = 0; i < steps.length; i++) {
-        let p = stepPhase(steps[i]);
-        if (!p)
-            p = cur;
-        if (PHASE_META[p].n < PHASE_META[cur].n)
-            p = cur;
-        cur = p;
-        out.push(p);
-    }
-    return out;
-}
-/**
- * EMERGENT grouping for the unified thread timeline. A segment is a run of
- * CONSECUTIVE steps that share a phase — so the sections are however many the
- * actual activity produced, not a fixed pipeline. No monotonic advance, no
- * "phase N of 5", no forced final stage: a one-read task yields one segment, a
- * sprawling task yields several. Unknown steps inherit the running phase so a
- * stray unclassified step doesn't fragment a run; leading unknowns (before any
- * classified step) produce no segment.
- *
- * This replaces classifySteps' fixed-5 framing for the timeline. stepPhase (the
- * per-step activity classifier) is reused unchanged.
- */
-export function segmentSteps(steps) {
-    const segs = [];
-    let cur = null;
-    for (let i = 0; i < steps.length; i++) {
-        let p = stepPhase(steps[i]);
-        if (!p)
-            p = cur;
-        if (!p)
-            continue;
-        if (p !== cur) {
-            segs.push({ phase: p, verb: PHASE_META[p].verb, from: i, count: 1 });
-            cur = p;
-        }
-        else {
-            segs[segs.length - 1].count++;
-        }
-    }
-    return segs;
-}
-/**
- * Browser-JS source for injection into the ui-page-v2 template literal. Emits
- * the same PHASE_META / stepPhase / segmentSteps the tests cover, so the
- * rendered thread uses the EXACT logic that's unit-tested. PHASE_ORDER +
- * classifySteps are still emitted during the timeline-restructure transition
- * (renderD's old phase-position line uses them); they go once renderD switches
- * to segmentSteps.
- */
-export const PHASE_CLASSIFIER_SRC = [
-    'var PHASE_ORDER=' + JSON.stringify(PHASE_ORDER) + ';',
-    'var PHASE_META=' + JSON.stringify(PHASE_META) + ';',
-    stepPhase.toString(),
-    classifySteps.toString(),
-    segmentSteps.toString(),
-].join('\n');
-//# sourceMappingURL=thread-phase.js.map