discoclaw 1.2.4 → 2.0.0

package/dist/dashboard/server.js

@@ -10,11 +10,15 @@ import { DASHBOARD_HOST, DEFAULT_DASHBOARD_PORT, formatDashboardUrl } from './op
 import { renderDashboardPage } from './page.js';
 import { buildSnapshotResponse } from './api/snapshot.js';
 import { buildSettingsGetResponse, buildSettingsPostResponse, } from './api/settings.js';
+import { buildMetricsResponse } from './api/metrics.js';
+import { buildTracesResponse } from './api/traces.js';
 import { hasErrorCode, mapListenError } from './server-errors.js';
 import { applyFixes, inspect, KNOWN_RUNTIMES, loadDoctorContext, updateEnvKey } from '../health/config-doctor.js';
 import { DEFAULTS as MODEL_DEFAULTS, saveModelConfig } from '../model-config.js';
 import { isModelTier } from '../runtime/model-tiers.js';
 import { saveOverrides } from '../runtime-overrides.js';
+import { findRuntimeForModel } from '../runtime/model-tiers.js';
+import { getRuntimePathDefinition } from '../runtime/runtime-path-contract.js';
 import { getPlatformCommands, getServiceLogs, getServiceStatus, normalizeServiceName, summarizeServiceStatus, } from '../service-control.js';
 const DASHBOARD_MODEL_ROLES = [
     'chat',
@@ -178,6 +182,9 @@ function normalizeRuntimeName(value, knownRuntimes) {
     const normalized = trimmed === 'claude_code' ? 'claude' : trimmed;
     return knownRuntimes.has(normalized) ? normalized : undefined;
 }
+function presetToPrimaryRuntime(preset) {
+    return preset === 'codex' ? 'codex-cli' : 'claude-cli';
+}
 async function loadServiceName(inspectOpts, deps) {
     const ctx = await deps.loadDoctorContext(inspectOpts);
     return normalizeServiceName(ctx.env.DISCOCLAW_SERVICE_NAME);
@@ -352,16 +359,14 @@ async function applyPreset(preset, inspectOpts, deps) {
         throw new Error(`Unknown preset: ${preset}. Allowed values: ${[...ALLOWED_PRESETS].join(', ')}`);
     }
     const ctx = await deps.loadDoctorContext(inspectOpts);
-    await deps.updateEnvKey(ctx.configPaths.env, 'PRIMARY_RUNTIME', preset);
-    const preservedOverrides = {};
-    if (ctx.runtimeOverrides.ttsVoice) {
-        preservedOverrides.ttsVoice = ctx.runtimeOverrides.ttsVoice;
-    }
-    await deps.saveOverrides(ctx.configPaths.runtimeOverrides, preservedOverrides);
+    const primaryRuntime = presetToPrimaryRuntime(preset);
+    await deps.updateEnvKey(ctx.configPaths.env, 'PRIMARY_RUNTIME', primaryRuntime);
+    await deps.saveOverrides(ctx.configPaths.runtimeOverrides, {});
     await deps.saveModelConfig(ctx.configPaths.models, { ...MODEL_DEFAULTS });
     return {
         message: `Preset switched to ${preset}. Models reset to tier defaults. Restart the service to apply.`,
-        snapshot: await collectDashboardSnapshot(inspectOpts, deps),
+        snapshot: await collectDashboardSnapshot({ cwd: inspectOpts.cwd, env: { ...inspectOpts.env, PRIMARY_RUNTIME: primaryRuntime } }, deps),
+        primaryRuntime,
     };
 }
 async function buildPresetResponse(input, inspectOpts, deps) {
@@ -373,6 +378,27 @@ async function buildPresetResponse(input, inspectOpts, deps) {
         ...await applyPreset(preset, inspectOpts, deps),
     };
 }
+async function persistChatRuntimeSelection(runtimeName, inspectOpts, deps) {
+    const ctx = await deps.loadDoctorContext(inspectOpts);
+    await deps.updateEnvKey(ctx.configPaths.env, 'PRIMARY_RUNTIME', runtimeName);
+    let nextModels = ctx.models;
+    let clearedCrossRuntimeOverride = false;
+    const targetRuntimeId = getRuntimePathDefinition(runtimeName)?.runtimeId;
+    const savedChatModel = ctx.models['chat'];
+    const savedChatModelRuntimeId = savedChatModel ? findRuntimeForModel(savedChatModel) : undefined;
+    if (savedChatModel && targetRuntimeId && savedChatModelRuntimeId && savedChatModelRuntimeId !== targetRuntimeId) {
+        nextModels = updateModelConfig(nextModels, 'chat', null);
+        await deps.saveModelConfig(ctx.configPaths.models, nextModels);
+        clearedCrossRuntimeOverride = true;
+    }
+    return {
+        message: clearedCrossRuntimeOverride
+            ? `Saved startup chat runtime: ${runtimeName}. Cleared the saved chat model override because it targeted a different provider. Restart the service to apply.`
+            : `Saved startup chat runtime: ${runtimeName}. Restart the service to apply.`,
+        snapshot: await collectDashboardSnapshot({ cwd: inspectOpts.cwd, env: { ...inspectOpts.env, PRIMARY_RUNTIME: runtimeName } }, deps),
+        primaryRuntime: runtimeName,
+    };
+}
 function isDashboardBadRequest(message) {
     return (message === 'Request body too large'
         || message === 'JSON body must be an object'
@@ -415,6 +441,11 @@ export async function startDashboardServer(opts = {}) {
     const liveAuthCheckHandler = opts.liveAuthCheckHandler;
     // Mutable flag — set when a persisted config change requires a restart to take effect.
     let pendingRestart = false;
+    const previewEnvOverrides = {};
+    const configInspectOpts = () => ({
+        cwd: inspectOpts.cwd,
+        env: { ...inspectOpts.env, ...previewEnvOverrides },
+    });
     const server = http.createServer(async (req, res) => {
         const method = req.method ?? 'GET';
         const requestHostname = parseHostHeaderHostname(req.headers.host);
@@ -422,14 +453,15 @@ export async function startDashboardServer(opts = {}) {
             respondJson(res, 403, { ok: false, message: DNS_REBIND_ERROR });
             return;
         }
-        const pathname = new URL(req.url ?? '/', `http://${DASHBOARD_HOST}`).pathname;
+        const parsedUrl = new URL(req.url ?? '/', `http://${DASHBOARD_HOST}`);
+        const pathname = parsedUrl.pathname;
         try {
             if (method === 'GET' && pathname === '/') {
                 respondHtml(res, 200, html);
                 return;
             }
             if (method === 'GET' && pathname === '/api/snapshot') {
-                respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot(await buildSnapshotResponse(inspectOpts, deps), opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
+                respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot(await buildSnapshotResponse(configInspectOpts(), deps), opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
                 return;
             }
             if (method === 'GET' && pathname === '/api/status') {
@@ -463,7 +495,7 @@ export async function startDashboardServer(opts = {}) {
                 return;
             }
             if (method === 'GET' && pathname === '/api/doctor') {
-                respondJson(res, 200, await buildDoctorResponse(inspectOpts, deps));
+                respondJson(res, 200, await buildDoctorResponse(configInspectOpts(), deps));
                 return;
             }
             if (pathname === '/api/doctor/fix') {
@@ -475,7 +507,7 @@ export async function startDashboardServer(opts = {}) {
                     respondJson(res, 403, { ok: false, message: CROSS_ORIGIN_MUTATION_ERROR });
                     return;
                 }
-                respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot(await buildDoctorFixResponse(inspectOpts, deps), opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
+                respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot(await buildDoctorFixResponse(configInspectOpts(), deps), opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
                 return;
             }
             if (pathname === '/api/live-model') {
@@ -494,6 +526,7 @@ export async function startDashboardServer(opts = {}) {
                 const body = await readJsonBody(req);
                 const role = typeof body.role === 'string' ? body.role.trim() : '';
                 const model = typeof body.model === 'string' ? body.model.trim() : '';
+                const persist = body.persist === true;
                 if (!role)
                     throw new Error('Model role is required.');
                 if (!model)
@@ -503,8 +536,24 @@ export async function startDashboardServer(opts = {}) {
                     respondJson(res, 400, { ok: false, message: result.error });
                     return;
                 }
-                const snapshot = await collectDashboardSnapshot(inspectOpts, deps);
-                respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot({ ok: true, message: result.summary, snapshot }, opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
+                let message = result.summary;
+                let snapshot = await collectDashboardSnapshot(configInspectOpts(), deps);
+                if (persist && role === 'chat') {
+                    const runtimeInput = normalizeRuntimeName(model, KNOWN_RUNTIMES);
+                    if (runtimeInput) {
+                        const persisted = await persistChatRuntimeSelection(runtimeInput, configInspectOpts(), deps);
+                        previewEnvOverrides['PRIMARY_RUNTIME'] = persisted.primaryRuntime;
+                        message = `${message} ${persisted.message}`;
+                        snapshot = persisted.snapshot;
+                    }
+                    else {
+                        const persisted = await applyModelChange({ role, model }, configInspectOpts(), deps, KNOWN_RUNTIMES);
+                        message = `${message} ${persisted.message}`;
+                        snapshot = persisted.snapshot;
+                    }
+                    pendingRestart = true;
+                }
+                respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot({ ok: true, message, snapshot }, opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
                 return;
             }
             if (pathname === '/api/model') {
@@ -517,7 +566,7 @@ export async function startDashboardServer(opts = {}) {
                     return;
                 }
                 const body = await readJsonBody(req);
-                const modelResponse = await buildModelResponse(body, inspectOpts, deps, KNOWN_RUNTIMES);
+                const modelResponse = await buildModelResponse(body, configInspectOpts(), deps, KNOWN_RUNTIMES);
                 pendingRestart = true;
                 respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot(modelResponse, opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
                 return;
@@ -532,7 +581,11 @@ export async function startDashboardServer(opts = {}) {
                     return;
                 }
                 const body = await readJsonBody(req);
-                const presetResponse = await buildPresetResponse(body, inspectOpts, deps);
+                const presetResponse = await buildPresetResponse(body, configInspectOpts(), deps);
+                const preset = typeof body.preset === 'string' ? body.preset.trim().toLowerCase() : '';
+                if (preset) {
+                    previewEnvOverrides['PRIMARY_RUNTIME'] = presetToPrimaryRuntime(preset);
+                }
                 pendingRestart = true;
                 respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot(presetResponse, opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
                 return;
@@ -555,10 +608,11 @@ export async function startDashboardServer(opts = {}) {
                     throw new Error(`Unknown secret key: ${key}`);
                 if (!value)
                     throw new Error('Secret value is required.');
-                const ctx = await deps.loadDoctorContext(inspectOpts);
+                const ctx = await deps.loadDoctorContext(configInspectOpts());
                 await deps.updateEnvKey(ctx.configPaths.env, key, value);
+                previewEnvOverrides[key] = value;
                 pendingRestart = true;
-                const snapshot = await collectDashboardSnapshot(inspectOpts, deps);
+                const snapshot = await collectDashboardSnapshot(configInspectOpts(), deps);
                 respondJson(res, 200, withLiveSnapshot(withStartupMcpSnapshot({ ok: true, message: `Updated ${key}. Restart the service to apply.`, snapshot }, opts.startupMcpStatus, opts.startupMcpWarnings), opts.liveSnapshotProvider, pendingRestart));
                 return;
             }
@@ -600,7 +654,7 @@ export async function startDashboardServer(opts = {}) {
                 return;
             }
             if (method === 'GET' && pathname === '/api/settings') {
-                respondJson(res, 200, buildSettingsGetResponse(inspectOpts.env));
+                respondJson(res, 200, buildSettingsGetResponse(configInspectOpts().env));
                 return;
             }
             if (pathname === '/api/settings') {
@@ -615,11 +669,20 @@ export async function startDashboardServer(opts = {}) {
                 const body = await readJsonBody(req);
                 const key = typeof body.key === 'string' ? body.key.trim() : '';
                 const value = typeof body.value === 'string' ? body.value.trim() : '';
-                const response = await buildSettingsPostResponse(inspectOpts, deps, key, value);
+                const response = await buildSettingsPostResponse(configInspectOpts(), deps, key, value);
+                previewEnvOverrides[key] = value;
                 pendingRestart = true;
                 respondJson(res, 200, response);
                 return;
             }
+            if (method === 'GET' && pathname === '/api/traces') {
+                respondJson(res, 200, buildTracesResponse(parsedUrl.searchParams.get('limit')));
+                return;
+            }
+            if (method === 'GET' && pathname === '/api/metrics') {
+                respondJson(res, 200, buildMetricsResponse());
+                return;
+            }
             respondJson(res, 404, { ok: false, message: 'Not found' });
         }
         catch (err) {

package/dist/dashboard/server.test.js

@@ -762,7 +762,6 @@ describe('startDashboardServer', () => {
         const ctx = makeDoctorContext({
             runtimeOverrides: {
                 fastRuntime: 'openrouter',
-                ttsVoice: 'alloy',
             },
             runtimeOverridesFile: {
                 exists: true,
@@ -770,15 +769,22 @@ describe('startDashboardServer', () => {
                 raw: {},
                 values: {
                     fastRuntime: 'openrouter',
-                    ttsVoice: 'alloy',
                 },
             },
         });
         const updateEnvKeyMock = vi.fn(async () => undefined);
         const saveModelConfigMock = vi.fn(async () => undefined);
         const saveOverridesMock = vi.fn(async () => undefined);
+        const loadDoctorContextMock = vi.fn(async (opts) => makeDoctorContext({
+            runtimeOverrides: ctx.runtimeOverrides,
+            runtimeOverridesFile: ctx.runtimeOverridesFile,
+            env: {
+                ...ctx.env,
+                ...(opts?.env ?? {}),
+            },
+        }));
         const { port } = await startServer({
-            loadDoctorContext: vi.fn(async () => ctx),
+            loadDoctorContext: loadDoctorContextMock,
             updateEnvKey: updateEnvKeyMock,
             saveModelConfig: saveModelConfigMock,
             saveOverrides: saveOverridesMock,
@@ -793,11 +799,11 @@ describe('startDashboardServer', () => {
         expect(body.ok).toBe(true);
         expect(body.message).toContain('codex');
         expect(body.message).toContain('tier defaults');
-        expect(updateEnvKeyMock).toHaveBeenCalledWith('/repo/.env', 'PRIMARY_RUNTIME', 'codex');
-        expect(saveOverridesMock).toHaveBeenCalledWith('/repo/data/runtime-overrides.json', { ttsVoice: 'alloy' });
+        expect(updateEnvKeyMock).toHaveBeenCalledWith('/repo/.env', 'PRIMARY_RUNTIME', 'codex-cli');
+        expect(saveOverridesMock).toHaveBeenCalledWith('/repo/data/runtime-overrides.json', {});
         expect(saveModelConfigMock).toHaveBeenCalledWith('/repo/data/models.json', expect.objectContaining({}));
         expect(body.snapshot).toBeDefined();
-        expect(body.snapshot.primaryRuntime).toBe('claude');
+        expect(body.snapshot.primaryRuntime).toBe('codex');
     });
     it('applies claude preset correctly on /api/preset', async () => {
         const ctx = makeDoctorContext();
@@ -819,14 +825,13 @@ describe('startDashboardServer', () => {
         expect(response.status).toBe(200);
         expect(body.ok).toBe(true);
         expect(body.message).toContain('claude');
-        expect(updateEnvKeyMock).toHaveBeenCalledWith('/repo/.env', 'PRIMARY_RUNTIME', 'claude');
+        expect(updateEnvKeyMock).toHaveBeenCalledWith('/repo/.env', 'PRIMARY_RUNTIME', 'claude-cli');
     });
-    it('preserves ttsVoice when clearing overrides via /api/preset', async () => {
+    it('clears legacy voice overrides when applying /api/preset', async () => {
         const ctx = makeDoctorContext({
             runtimeOverrides: {
                 fastRuntime: 'openrouter',
                 voiceRuntime: 'anthropic',
-                ttsVoice: 'shimmer',
             },
         });
         const saveOverridesMock = vi.fn(async () => undefined);
@@ -840,7 +845,7 @@ describe('startDashboardServer', () => {
             method: 'POST',
             body: JSON.stringify({ preset: 'codex' }),
         });
-        expect(saveOverridesMock).toHaveBeenCalledWith('/repo/data/runtime-overrides.json', { ttsVoice: 'shimmer' });
+        expect(saveOverridesMock).toHaveBeenCalledWith('/repo/data/runtime-overrides.json', {});
     });
     it('rejects GET requests on /api/model', async () => {
         const { port } = await startServer();
@@ -1125,6 +1130,114 @@ describe('startDashboardServer', () => {
         expect(body.snapshot).toBeDefined();
         expect(liveModelHandler).toHaveBeenCalledWith('chat', 'opus');
     });
+    it('persists chat runtime changes requested from /api/live-model', async () => {
+        const ctx = makeDoctorContext({
+            models: {
+                chat: 'claude-opus-4-6',
+            },
+            modelsFile: {
+                exists: true,
+                values: {
+                    chat: 'claude-opus-4-6',
+                },
+            },
+        });
+        const liveModelHandler = vi.fn(() => ({
+            ok: true,
+            summary: 'Model updated: runtime → codex-cli, chat → gpt-5.4 (adapter default)',
+        }));
+        const updateEnvKeyMock = vi.fn(async () => undefined);
+        const saveModelConfigMock = vi.fn(async () => undefined);
+        const loadDoctorContextMock = vi.fn(async (opts) => makeDoctorContext({
+            models: ctx.models,
+            modelsFile: ctx.modelsFile,
+            env: {
+                ...ctx.env,
+                ...(opts?.env ?? {}),
+            },
+        }));
+        const { port } = await startServer({
+            loadDoctorContext: loadDoctorContextMock,
+            updateEnvKey: updateEnvKeyMock,
+            saveModelConfig: saveModelConfigMock,
+        }, {
+            liveModelHandler,
+            liveSnapshotProvider: () => ({
+                chatRuntime: 'codex-cli',
+                chatModel: 'gpt-5.4',
+                chatThinking: 'high',
+                availableRuntimes: ['claude-cli', 'codex-cli'],
+                pendingRestart: false,
+                imagegenProvider: undefined,
+                imagegenModel: undefined,
+                imagegenOptions: [],
+                imagegenHasGeminiKey: false,
+                imagegenHasOpenaiKey: false,
+            }),
+        });
+        const response = await makeRequest(port, {
+            path: '/api/live-model',
+            method: 'POST',
+            body: JSON.stringify({ role: 'chat', model: 'codex-cli', persist: true }),
+        });
+        const body = parseJson(response.text);
+        expect(response.status).toBe(200);
+        expect(body.ok).toBe(true);
+        expect(body.message).toContain('runtime → codex-cli');
+        expect(body.message).toContain('Saved startup chat runtime: codex-cli.');
+        expect(body.snapshot.primaryRuntime).toBe('codex');
+        expect(body.snapshot.live?.pendingRestart).toBe(true);
+        expect(updateEnvKeyMock).toHaveBeenCalledWith('/repo/.env', 'PRIMARY_RUNTIME', 'codex-cli');
+        expect(saveModelConfigMock).toHaveBeenCalledWith('/repo/data/models.json', {});
+    });
+    it('persists chat model changes requested from /api/live-model', async () => {
+        const ctx = makeDoctorContext({
+            env: {
+                DISCOCLAW_SERVICE_NAME: 'discoclaw-beta',
+                PRIMARY_RUNTIME: 'codex-cli',
+            },
+            models: {},
+            modelsFile: {
+                exists: true,
+                values: {},
+            },
+        });
+        const liveModelHandler = vi.fn(() => ({
+            ok: true,
+            summary: 'Model updated: chat → gpt-5.4',
+        }));
+        const saveModelConfigMock = vi.fn(async () => undefined);
+        const { port } = await startServer({
+            loadDoctorContext: vi.fn(async () => ctx),
+            saveModelConfig: saveModelConfigMock,
+        }, {
+            liveModelHandler,
+            liveSnapshotProvider: () => ({
+                chatRuntime: 'codex-cli',
+                chatModel: 'gpt-5.4',
+                chatThinking: 'high',
+                availableRuntimes: ['claude-cli', 'codex-cli'],
+                pendingRestart: false,
+                imagegenProvider: undefined,
+                imagegenModel: undefined,
+                imagegenOptions: [],
+                imagegenHasGeminiKey: false,
+                imagegenHasOpenaiKey: false,
+            }),
+        });
+        const response = await makeRequest(port, {
+            path: '/api/live-model',
+            method: 'POST',
+            body: JSON.stringify({ role: 'chat', model: 'gpt-5.4', persist: true }),
+        });
+        const body = parseJson(response.text);
+        expect(response.status).toBe(200);
+        expect(body.ok).toBe(true);
+        expect(body.message).toContain('Model updated: chat → gpt-5.4');
+        expect(body.message).toContain('Saved chat override: gpt-5.4. Changes take effect on next service restart.');
+        expect(body.snapshot.live?.pendingRestart).toBe(true);
+        expect(saveModelConfigMock).toHaveBeenCalledWith('/repo/data/models.json', { chat: 'gpt-5.4' });
+    });
     it('returns 400 when live model handler rejects the change', async () => {
         const liveModelHandler = vi.fn(() => ({
             ok: false,

package/dist/discord/actions.js

@@ -534,21 +534,127 @@ export function buildAllResultLines(results) {
     return results.map((r) => r.ok ? `Done: ${r.summary}` : `Failed: ${r.error}`);
 }
 /**
- * Cap a single result line to approximately `maxChars` characters.
+ * Cap a single result line to `maxChars` characters.
  * If truncated, appends a visible `...[truncated]` suffix.
  */
 export function capResultLine(line, maxChars = 1500) {
     if (line.length <= maxChars)
         return line;
-    return `${line.slice(0, maxChars)}...[truncated]`;
+    const suffix = '...[truncated]';
+    if (maxChars <= suffix.length)
+        return suffix.slice(0, maxChars);
+    return `${line.slice(0, maxChars - suffix.length)}${suffix}`;
+}
+const RESULT_LINE_PREFIX_RE = /^(Done|Failed):\s*/;
+const RESULT_LINE_IMPORTANT_FIELD_RE = /^(Status|Thread|Model|Next run|Last error|State):\s/i;
+const RESULT_LINE_GENERIC_FIELD_RE = /^[A-Z][A-Za-z0-9 /_-]{1,24}:\s/;
+const RESULT_LINE_SECTION_HEADER_RE = /^\*\*[^*\n]+:\*\*$/;
+const RESULT_LINE_ERROR_RE = /\b(error|failed|failure|missing|invalid|denied|not found|cannot|unable|exception|timeout|timed out)\b/i;
+const RESULT_LINE_PATH_RE = /(?:^|[\s(])(?:\/[^\s)`]+|\.{1,2}\/[^\s)`]+|[A-Za-z]:\\\S+)/;
+const RESULT_LINE_ID_RE = /\b(?:id[:=][^\s,)]+|[a-z]+-\d+\b|\d{8,})/i;
+const RESULT_LINE_NEXT_ACTION_RE = /\b(?:retry|rerun|re-run|resume|check|open|use)\b/i;
+const RESULT_LINE_MICROCOMPACT_TRIGGER_LINES = 6;
+const RESULT_LINE_MICROCOMPACT_TRIGGER_CHARS = 500;
+const RESULT_LINE_MAX_RETAINED_LINES = 8;
+const RESULT_LINE_ID_REPRESENTATIVE_COUNT = 4;
+const RESULT_LINE_REMAINDER_REPRESENTATIVE_COUNT = 2;
+function splitResultLine(line) {
+    const match = RESULT_LINE_PREFIX_RE.exec(line);
+    if (!match)
+        return { prefix: '', body: line };
+    return { prefix: match[0], body: line.slice(match[0].length) };
+}
+function parseResultLineBody(body) {
+    return body
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.trim().length > 0)
+        .map((text, index) => ({
+        index,
+        text,
+        isImportantField: RESULT_LINE_IMPORTANT_FIELD_RE.test(text),
+        isGenericField: RESULT_LINE_GENERIC_FIELD_RE.test(text),
+        isSectionHeader: RESULT_LINE_SECTION_HEADER_RE.test(text),
+        hasErrorText: RESULT_LINE_ERROR_RE.test(text),
+        hasPath: RESULT_LINE_PATH_RE.test(text),
+        hasId: RESULT_LINE_ID_RE.test(text),
+        hasNextAction: RESULT_LINE_NEXT_ACTION_RE.test(text),
+    }));
+}
+function takeRepresentativeIndexes(indexes, count) {
+    if (indexes.length <= count)
+        return indexes;
+    const headCount = Math.ceil(count / 2);
+    const tailCount = Math.floor(count / 2);
+    return [...indexes.slice(0, headCount), ...indexes.slice(-tailCount)];
+}
+function appendUniqueIndexes(target, indexes, maxCount) {
+    for (const index of indexes) {
+        if (target.includes(index))
+            continue;
+        target.push(index);
+        if (target.length >= maxCount)
+            return;
+    }
+}
+function collectSectionValueIndexes(lines) {
+    const indexes = [];
+    for (let i = 0; i < lines.length - 1; i += 1) {
+        if (!lines[i]?.isSectionHeader)
+            continue;
+        indexes.push(lines[i + 1].index);
+    }
+    return indexes;
+}
+function buildResultLineOmissionMarker(omittedCount) {
+    return `...[omitted ${omittedCount} line${omittedCount === 1 ? '' : 's'}]`;
+}
+function selectInformativeResultBodyIndexes(lines) {
+    if (lines.length <= RESULT_LINE_MAX_RETAINED_LINES)
+        return lines.map((line) => line.index);
+    const maxCount = Math.min(RESULT_LINE_MAX_RETAINED_LINES, lines.length);
+    const selected = [];
+    appendUniqueIndexes(selected, [0], maxCount);
+    appendUniqueIndexes(selected, lines.filter((line) => line.isImportantField).map((line) => line.index), maxCount);
+    appendUniqueIndexes(selected, lines
+        .filter((line) => line.hasErrorText || line.hasPath || line.hasNextAction)
+        .map((line) => line.index), maxCount);
+    appendUniqueIndexes(selected, lines.filter((line) => line.isSectionHeader).map((line) => line.index), maxCount);
+    appendUniqueIndexes(selected, collectSectionValueIndexes(lines), maxCount);
+    appendUniqueIndexes(selected, takeRepresentativeIndexes(lines.filter((line) => line.hasId).map((line) => line.index), RESULT_LINE_ID_REPRESENTATIVE_COUNT), maxCount);
+    appendUniqueIndexes(selected, [lines.length - 1], maxCount);
+    appendUniqueIndexes(selected, takeRepresentativeIndexes(lines
+        .filter((line) => !line.isGenericField && !line.isSectionHeader && !line.hasId)
+        .map((line) => line.index), RESULT_LINE_REMAINDER_REPRESENTATIVE_COUNT), maxCount);
+    return selected.sort((a, b) => a - b);
+}
+function microcompactResultLine(line, maxChars) {
+    const { prefix, body } = splitResultLine(line);
+    const parsedLines = parseResultLineBody(body);
+    if (parsedLines.length <= 1)
+        return capResultLine(line, maxChars);
+    const shouldCompact = parsedLines.length > RESULT_LINE_MICROCOMPACT_TRIGGER_LINES
+        || body.length > Math.min(maxChars, RESULT_LINE_MICROCOMPACT_TRIGGER_CHARS);
+    if (!shouldCompact)
+        return capResultLine(line, maxChars);
+    const selectedIndexes = selectInformativeResultBodyIndexes(parsedLines);
+    if (selectedIndexes.length >= parsedLines.length)
+        return capResultLine(line, maxChars);
+    const selectedIndexSet = new Set(selectedIndexes);
+    const retainedLines = parsedLines
+        .filter((lineInfo) => selectedIndexSet.has(lineInfo.index))
+        .map((lineInfo) => lineInfo.text);
+    const omittedCount = parsedLines.length - retainedLines.length;
+    const compactedBody = `${retainedLines.join('\n')}\n${buildResultLineOmissionMarker(omittedCount)}`;
+    return capResultLine(`${prefix}${compactedBody}`, maxChars);
 }
 /**
- * Build result lines for follow-up prompts with per-line length capping.
- * Each line is capped at `maxChars` characters to prevent oversized payloads
- * from crowding out reasoning and action blocks in follow-up prompts.
+ * Build result lines for follow-up prompts with microcompaction before
+ * the final hard cap so oversized payloads preserve continuation-critical
+ * details without crowding out reasoning and action blocks.
  */
 export function buildCappedResultLines(results, maxChars = 1500) {
-    return buildAllResultLines(results).map((line) => capResultLine(line, maxChars));
+    return buildAllResultLines(results).map((line) => microcompactResultLine(line, maxChars));
 }
 /**
  * Append display result lines to body text, automatically closing any