muonroi-cli 1.7.1 → 1.8.0

package/dist/src/ee/who-am-i.js

@@ -0,0 +1,143 @@
+// src/ee/who-am-i.ts
+//
+// "Who Am I" v4.0 profile provider for the PIL. The personality/work-style profile
+// is DEVICE-LOCAL (~/.experience/profile.yaml) and never leaves the machine, so it
+// cannot come from the EE HTTP API — we read it on-device, reusing the EE install's
+// parser (profile-model.js loadProfile) + privacy gate (config.js getPrivacyLevel)
+// via createRequire (the same in-process pattern as src/ee/bridge.ts).
+//
+// Privacy is enforced HERE at read time via a positive per-dimension-NAME allowlist
+// (defense in depth): the EE writer keeps committed values regardless of privacyLevel,
+// so a standard→minimal downgrade leaves stale Tang-2 values physically in the file —
+// trusting the file would leak opted-out data. Mirrors experience-engine
+// src/profile-render.js. Fail-open: any error / missing EE install returns null and the
+// PIL keeps its own per-turn defaults.
+import { createRequire } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
+// Tang 1 (work patterns + activity-derived decision_speed — namespaced personality.*
+// but its SOURCE is activity, so it belongs to the minimal tier; allowlist by NAME).
+const TIER_MINIMAL = [
+    "work_patterns.energy",
+    "work_patterns.multitasking",
+    "work_patterns.session_length",
+    "personality.decision_speed",
+];
+// Tang 2 (decision + communication style) added at standard. `full` == standard today
+// (no Tang-3 emotional dims exist); the allowlist guarantees emotional.* can never leak.
+const TIER_STANDARD = [
+    ...TIER_MINIMAL,
+    "communication.question_style",
+    "communication.feedback_style",
+    "communication.brevity",
+    "personality.conflict_style",
+    "personality.risk_tolerance",
+    // delegation_style is `work_patterns.*` by name but transcript-derived, so it commits
+    // only at standard+ (the EE writer skips the transcript at `minimal`). Standard-only.
+    "work_patterns.delegation_style",
+];
+const ALLOWLIST = {
+    minimal: TIER_MINIMAL,
+    standard: TIER_STANDARD,
+    full: TIER_STANDARD,
+};
+const WORK_DIMS = new Set(TIER_MINIMAL);
+// Coarse work dims commit over 2-3-way splits (confidence ~0.45-0.6); the lower floor
+// keeps the minimal tier usable. Mirrors experience-engine src/profile-render.js.
+const WORK_MIN_CONFIDENCE = 0.45;
+const MIN_CONFIDENCE = 0.6;
+/**
+ * PURE: project a raw EE profile to the privacy-gated dims for `level`, applying the
+ * positive name allowlist + value!=null commit gate + per-tier confidence floor.
+ */
+export function selectWhoAmIDims(raw, level) {
+    const out = {};
+    const allow = ALLOWLIST[level];
+    if (!allow || !raw?.dimensions)
+        return out;
+    for (const name of allow) {
+        const d = raw.dimensions[name];
+        if (!d || d.value == null)
+            continue;
+        const confidence = Number(d.confidence) || 0;
+        const floor = WORK_DIMS.has(name) ? WORK_MIN_CONFIDENCE : MIN_CONFIDENCE;
+        if (confidence < floor)
+            continue;
+        out[name] = {
+            value: String(d.value),
+            confidence,
+            samples: Math.round(Number(d.sampleCount ?? d.samples) || 0),
+        };
+    }
+    return out;
+}
+/**
+ * PURE: derive an output-style baseline from the profile. brevity is the primary
+ * signal; decision_speed is a weaker fallback. Returns null when no usable signal
+ * exists so the caller keeps its own per-turn default.
+ */
+export function outputStyleFromProfile(profile) {
+    if (!profile)
+        return null;
+    const brevity = profile.dims["communication.brevity"]?.value;
+    if (brevity === "concise")
+        return "concise";
+    if (brevity === "verbose")
+        return "detailed";
+    if (brevity === "moderate")
+        return "balanced";
+    const speed = profile.dims["personality.decision_speed"]?.value;
+    if (speed === "fast-intuitive")
+        return "concise";
+    if (speed === "deliberate")
+        return "detailed";
+    return null;
+}
+let _cache;
+/**
+ * Load + cache the privacy-gated profile for this process. The profile changes
+ * slowly (rebuilt by the EE Stop hook), so one read per process is enough.
+ * Returns null when EE is not installed, privacy is off, or nothing is committed.
+ */
+export function getWhoAmIProfile() {
+    if (_cache !== undefined)
+        return _cache;
+    _cache = loadWhoAmIProfile();
+    return _cache;
+}
+/** Clear the cache — test-only / after a known profile change. */
+export function resetWhoAmICache() {
+    _cache = undefined;
+}
+function loadWhoAmIProfile() {
+    try {
+        const req = createRequire(import.meta.url);
+        const srcDir = path.join(os.homedir(), ".experience", "src");
+        const config = req(path.join(srcDir, "config.js"));
+        const model = req(path.join(srcDir, "profile-model.js"));
+        if (typeof config.getPrivacyLevel !== "function" || typeof config.getProfilePath !== "function")
+            return null;
+        if (typeof model.loadProfile !== "function")
+            return null;
+        const level = String(config.getPrivacyLevel() ?? "off");
+        if (level !== "minimal" && level !== "standard" && level !== "full")
+            return null;
+        const raw = model.loadProfile(config.getProfilePath());
+        const dims = selectWhoAmIDims(raw, level);
+        if (Object.keys(dims).length === 0)
+            return null;
+        return { level, dims };
+    }
+    catch (err) {
+        // EE not installed (module absent) is an expected feature-off condition, not a
+        // failure — stay quiet. Any other error (corrupt profile, throwing module) is a
+        // real fault: log it (No-Silent-Catch) and degrade.
+        const code = err?.code;
+        if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
+            logEeFailure("who-am-i.load", classifyEeError(err), err);
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=who-am-i.js.map

package/dist/src/ee/who-am-i.test.d.ts

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

package/dist/src/ee/who-am-i.test.js

@@ -0,0 +1,101 @@
+import * as os from "node:os";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { getWhoAmIProfile, outputStyleFromProfile, resetWhoAmICache, selectWhoAmIDims, } from "./who-am-i.js";
+// Build a raw EE profile (the shape ~/.experience/src/profile-model.js loadProfile() returns).
+function rawDim(value, confidence, sampleCount = 20) {
+    return { value, confidence, sampleCount, distribution: {}, evidence: null };
+}
+function rawProfile(dims) {
+    return { version: 1, updatedAt: null, dimensions: dims };
+}
+describe("selectWhoAmIDims — privacy allowlist + commit/confidence gates", () => {
+    const all = () => rawProfile({
+        "communication.question_style": rawDim("directive", 0.8),
+        "communication.feedback_style": rawDim("implicit", 0.75),
+        "communication.brevity": rawDim("concise", 0.83),
+        "personality.conflict_style": rawDim("direct-constructive", 0.7),
+        "personality.risk_tolerance": rawDim("experimental", 0.72),
+        "personality.decision_speed": rawDim("fast-intuitive", 0.7),
+        "work_patterns.energy": rawDim("night-owl", 0.6),
+        "work_patterns.multitasking": rawDim("sequential-deep", 0.65),
+        "work_patterns.session_length": rawDim("long", 0.55),
+        "work_patterns.delegation_style": rawDim("autonomous", 0.68),
+    });
+    test("minimal exposes only the 4 Tang-1 work dims", () => {
+        const dims = selectWhoAmIDims(all(), "minimal");
+        expect(Object.keys(dims).sort()).toEqual([
+            "personality.decision_speed",
+            "work_patterns.energy",
+            "work_patterns.multitasking",
+            "work_patterns.session_length",
+        ].sort());
+    });
+    test("standard exposes all 10 committed dims", () => {
+        const dims = selectWhoAmIDims(all(), "standard");
+        expect(Object.keys(dims).length).toBe(10);
+    });
+    test("delegation_style is standard-only — stripped at minimal (transcript-derived, not Tang-1)", () => {
+        expect(selectWhoAmIDims(all(), "minimal")["work_patterns.delegation_style"]).toBeUndefined();
+        expect(selectWhoAmIDims(all(), "standard")["work_patterns.delegation_style"]).toBeDefined();
+    });
+    test("standard-built profile rendered at minimal strips Tang-2 dims (no stale leak)", () => {
+        const dims = selectWhoAmIDims(all(), "minimal");
+        expect(dims["communication.brevity"]).toBeUndefined();
+        expect(dims["personality.conflict_style"]).toBeUndefined();
+    });
+    test("pending (value=null) dims are skipped", () => {
+        const dims = selectWhoAmIDims(rawProfile({ "communication.brevity": rawDim(null, 0.9, 5) }), "standard");
+        expect(Object.keys(dims).length).toBe(0);
+    });
+    test("per-tier confidence floors: 0.55 Tang-2 drops at 0.6, 0.50 work survives at 0.45", () => {
+        const dims = selectWhoAmIDims(rawProfile({
+            "communication.brevity": rawDim("concise", 0.55),
+            "work_patterns.energy": rawDim("night-owl", 0.5),
+        }), "standard");
+        expect(dims["communication.brevity"]).toBeUndefined();
+        expect(dims["work_patterns.energy"]).toBeDefined();
+    });
+    test("Tang-3 emotional.* is never exposed (not in any allowlist)", () => {
+        const dims = selectWhoAmIDims(rawProfile({ "emotional.mood": rawDim("calm", 0.99) }), "full");
+        expect(Object.keys(dims).length).toBe(0);
+    });
+    test("decision_speed (personality.* but Tang-1) is allowed at minimal — namespace trap", () => {
+        const dims = selectWhoAmIDims(rawProfile({ "personality.decision_speed": rawDim("measured", 0.7) }), "minimal");
+        expect(dims["personality.decision_speed"]).toBeDefined();
+    });
+});
+describe("outputStyleFromProfile — brevity/decision_speed → OutputStyle", () => {
+    const p = (dims) => ({ level: "standard", dims });
+    test("brevity concise → concise, verbose → detailed, moderate → balanced", () => {
+        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "concise", confidence: 0.8, samples: 20 } }))).toBe("concise");
+        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "verbose", confidence: 0.8, samples: 20 } }))).toBe("detailed");
+        expect(outputStyleFromProfile(p({ "communication.brevity": { value: "moderate", confidence: 0.8, samples: 20 } }))).toBe("balanced");
+    });
+    test("no brevity → decision_speed fast-intuitive → concise; deliberate → detailed", () => {
+        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "fast-intuitive", confidence: 0.7, samples: 20 } }))).toBe("concise");
+        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "deliberate", confidence: 0.7, samples: 20 } }))).toBe("detailed");
+    });
+    test("null profile or no usable dim → null (caller keeps its own default)", () => {
+        expect(outputStyleFromProfile(null)).toBeNull();
+        expect(outputStyleFromProfile(p({ "personality.decision_speed": { value: "measured", confidence: 0.7, samples: 20 } }))).toBeNull();
+    });
+});
+describe("getWhoAmIProfile — fail-open + cache", () => {
+    const origHome = process.env.HOME;
+    const origUser = process.env.USERPROFILE;
+    beforeEach(() => {
+        resetWhoAmICache();
+    });
+    afterEach(() => {
+        process.env.HOME = origHome;
+        process.env.USERPROFILE = origUser;
+        resetWhoAmICache();
+    });
+    test("returns null when no EE install is present (no ~/.experience modules)", () => {
+        const empty = os.tmpdir(); // no .experience/src here
+        process.env.HOME = empty;
+        process.env.USERPROFILE = empty;
+        expect(getWhoAmIProfile()).toBeNull();
+    });
+});
+//# sourceMappingURL=who-am-i.test.js.map

package/dist/src/generated/version.d.ts

@@ -1,2 +1,2 @@
-export declare const PACKAGE_VERSION = "1.7.1";
+export declare const PACKAGE_VERSION = "1.8.0";
 export declare const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";

package/dist/src/generated/version.js

@@ -1,5 +1,5 @@
 // AUTO-GENERATED by scripts/sync-version.cjs. DO NOT EDIT BY HAND.
 // Sourced from package.json at build time so it survives bun --compile bundling.
-export const PACKAGE_VERSION = "1.7.1";
+export const PACKAGE_VERSION = "1.8.0";
 export const PACKAGE_DESCRIPTION = "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.";
 //# sourceMappingURL=version.js.map

package/dist/src/headless/council-answers.js

@@ -9,6 +9,7 @@ export function createCouncilAutoAnswerer(opts) {
         "pil-interview": [],
         "pil-acceptance": [],
         "tool-loop-cap": [],
+        "safety-override": [],
     };
     const preflightApprove = opts.file?.preflightApprove ?? true;
     return {

package/dist/src/headless/output.d.ts

@@ -1,5 +1,5 @@
 import type { ProcessMessageObserver } from "../orchestrator/agent-options.js";
-import type { StreamChunk, ToolCall, ToolResult } from "../types/index.js";
+import type { StreamChunk, StructuredResponse, ToolCall, ToolResult } from "../types/index.js";
 export type HeadlessOutputFormat = "text" | "json";
 export interface HeadlessWrites {
     stdout?: string;
@@ -42,6 +42,13 @@ export type HeadlessJsonEvent = {
         totalTokens?: number;
         costUsdTicks?: number;
     };
+} | {
+    type: "structured_response";
+    sessionID?: string;
+    stepNumber: number;
+    timestamp: number;
+    taskType: string;
+    data: Record<string, unknown>;
 } | {
     type: "error";
     sessionID?: string;
@@ -54,6 +61,28 @@ export declare function renderHeadlessPrelude(format: HeadlessOutputFormat, sess
  * Headless text output only. JSON streaming uses {@link createHeadlessJsonlEmitter} + `Agent.processMessage` observer.
  */
 export declare function renderHeadlessChunk(chunk: StreamChunk): HeadlessWrites;
+/**
+ * Plain-text rendering of a respond_* terminal answer for headless `--format
+ * text`. Mirrors the per-taskType layout of {@link StructuredResponseView}
+ * (src/ui/components/structured-response-view.tsx) but emits flat text (no ANSI
+ * box-drawing) so the answer pipes cleanly. Falls back to the primary text
+ * field, then raw JSON, for taskTypes without a dedicated layout.
+ */
+export declare function formatStructuredResponseText(sr: StructuredResponse): string;
+/**
+ * Stateful headless TEXT consumer. Streams tool/error progress to stderr (via
+ * {@link renderHeadlessChunk}) but BUFFERS assistant `content` so that a
+ * terminal `respond_*` answer ({@link StructuredResponse}) supersedes any
+ * preamble the model leaked before calling the response tool — otherwise the
+ * answer would print twice (once as raw leaked content, once formatted). For a
+ * normal chat turn with no structured answer, the buffered content is flushed
+ * verbatim at the end. Mirrors the buffer-and-supersede design of
+ * {@link createHeadlessJsonlEmitter}.
+ */
+export declare function createHeadlessTextEmitter(): {
+    consumeChunk(chunk: StreamChunk): HeadlessWrites;
+    flush(): HeadlessWrites;
+};
 /**
  * Buffers assistant `content` per step and emits JSONL: step_start, text, tool_use, step_finish, error.
  * Pair with `agent.processMessage(prompt, emitter.observer)` in headless JSON mode only.

package/dist/src/headless/output.js

@@ -39,6 +39,11 @@ export function renderHeadlessChunk(chunk) {
             const stderr = [`${color}${icon} ${label}\x1b[0m`, ...mediaLines].join("\n");
             return { stderr: `${stderr}\n` };
         }
+        case "structured_response":
+            // A respond_* terminal answer arrives ONLY as this chunk (never as
+            // `content`). Without this case it hit the no-op default below and the
+            // answer was silently dropped from `--format text` stdout.
+            return chunk.structuredResponse ? { stdout: `${formatStructuredResponseText(chunk.structuredResponse)}\n` } : {};
         case "error":
             return chunk.content ? { stderr: `\x1b[31m${chunk.content}\x1b[0m\n` } : {};
         case "done":
@@ -52,6 +57,119 @@ export function renderHeadlessChunk(chunk) {
 function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
+/**
+ * Plain-text rendering of a respond_* terminal answer for headless `--format
+ * text`. Mirrors the per-taskType layout of {@link StructuredResponseView}
+ * (src/ui/components/structured-response-view.tsx) but emits flat text (no ANSI
+ * box-drawing) so the answer pipes cleanly. Falls back to the primary text
+ * field, then raw JSON, for taskTypes without a dedicated layout.
+ */
+export function formatStructuredResponseText(sr) {
+    const d = (sr.data ?? {});
+    const str = (v) => (typeof v === "string" ? v : "");
+    const arr = (v) => (Array.isArray(v) ? v : []);
+    switch (sr.taskType) {
+        case "general":
+            return str(d.response) || JSON.stringify(d, null, 2);
+        case "documentation": {
+            const examples = arr(d.examples);
+            const parts = [str(d.content)];
+            for (const ex of examples) {
+                if (ex.description)
+                    parts.push(`\n${ex.description}`);
+                if (ex.code)
+                    parts.push(ex.code);
+            }
+            const out = parts.filter(Boolean).join("\n");
+            return out || JSON.stringify(d, null, 2);
+        }
+        case "analyze": {
+            const findings = arr(d.findings);
+            if (findings.length === 0)
+                return JSON.stringify(d, null, 2);
+            return findings
+                .map((f) => {
+                const sev = (f.severity ?? "").toUpperCase();
+                const head = sev ? `[${sev}] ${f.text ?? ""}` : (f.text ?? "");
+                return f.evidence ? `${head}\n  evidence: ${f.evidence}` : head;
+            })
+                .join("\n");
+        }
+        case "plan": {
+            const steps = arr(d.steps);
+            const lines = [];
+            steps.forEach((s, i) => {
+                lines.push(`${i + 1}. ${s.action ?? ""}`);
+                if (s.criterion)
+                    lines.push(`   done when: ${s.criterion}`);
+                if (s.rationale)
+                    lines.push(`   why: ${s.rationale}`);
+            });
+            const assumptions = arr(d.assumptions);
+            const risks = arr(d.risks);
+            if (assumptions.length > 0) {
+                lines.push("", "assumptions:");
+                for (const a of assumptions)
+                    lines.push(`  - ${a}`);
+            }
+            if (risks.length > 0) {
+                lines.push("", "risks:");
+                for (const rk of risks)
+                    lines.push(`  - ${rk}`);
+            }
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        case "debug": {
+            const r = d;
+            const lines = [];
+            if (r.hypothesis)
+                lines.push(`hypothesis: ${r.hypothesis}`);
+            if (r.root_cause)
+                lines.push(`root cause: ${r.root_cause}`);
+            if (r.fix?.file)
+                lines.push(`fix: ${r.fix.file}`);
+            if (r.fix?.diff)
+                lines.push(r.fix.diff);
+            if (r.verify_command)
+                lines.push(`verify: ${r.verify_command}`);
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        case "refactor": {
+            const r = d;
+            const lines = [];
+            if (r.summary)
+                lines.push(r.summary);
+            for (const c of r.changes ?? []) {
+                if (c.file)
+                    lines.push(`\n── ${c.file} ──`);
+                if (c.diff)
+                    lines.push(c.diff);
+            }
+            if (r.verify_command)
+                lines.push(`verify: ${r.verify_command}`);
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        case "generate": {
+            const r = d;
+            const lines = [];
+            if (r.explanation)
+                lines.push(r.explanation);
+            for (const f of r.files ?? []) {
+                const lang = f.language ? ` (${f.language})` : "";
+                if (f.path)
+                    lines.push(`\n── ${f.path}${lang} ──`);
+                if (f.content)
+                    lines.push(f.content);
+            }
+            return lines.length > 0 ? lines.join("\n") : JSON.stringify(d, null, 2);
+        }
+        default: {
+            // Renderer-missing taskType: probe common text-bearing fields, then JSON.
+            const primary = str(d.response) || str(d.summary) || str(d.content) || str(d.text);
+            return primary || JSON.stringify(d, null, 2);
+        }
+    }
+}
 function formatToolCallLabel(tc) {
     const name = tc.function.name;
     try {
@@ -74,6 +192,45 @@ function formatToolCallLabel(tc) {
     catch { }
     return name;
 }
+/**
+ * Stateful headless TEXT consumer. Streams tool/error progress to stderr (via
+ * {@link renderHeadlessChunk}) but BUFFERS assistant `content` so that a
+ * terminal `respond_*` answer ({@link StructuredResponse}) supersedes any
+ * preamble the model leaked before calling the response tool — otherwise the
+ * answer would print twice (once as raw leaked content, once formatted). For a
+ * normal chat turn with no structured answer, the buffered content is flushed
+ * verbatim at the end. Mirrors the buffer-and-supersede design of
+ * {@link createHeadlessJsonlEmitter}.
+ */
+export function createHeadlessTextEmitter() {
+    let pendingContent = "";
+    let structuredEmitted = false;
+    function consumeChunk(chunk) {
+        switch (chunk.type) {
+            case "content":
+                pendingContent += chunk.content ?? "";
+                return {};
+            case "structured_response":
+                if (!chunk.structuredResponse)
+                    return {};
+                // Terminal answer is authoritative — drop any buffered preamble.
+                pendingContent = "";
+                structuredEmitted = true;
+                return { stdout: `${formatStructuredResponseText(chunk.structuredResponse)}\n` };
+            case "done":
+                // Trailing newline is emitted by flush() alongside the final answer.
+                return {};
+            default:
+                return renderHeadlessChunk(chunk);
+        }
+    }
+    function flush() {
+        if (structuredEmitted || pendingContent.length === 0)
+            return {};
+        return { stdout: `${pendingContent}\n` };
+    }
+    return { consumeChunk, flush };
+}
 function jsonLine(event) {
     return `${JSON.stringify(event)}\n`;
 }
@@ -188,6 +345,29 @@ export function createHeadlessJsonlEmitter(sessionId) {
                 }
                 break;
             }
+            case "structured_response": {
+                if (chunk.structuredResponse) {
+                    // Flush any buffered preamble text first so ordering is preserved,
+                    // then emit the typed terminal answer (previously dropped entirely).
+                    if (textBuffer.length > 0) {
+                        stdout += jsonLine(withSession({
+                            type: "text",
+                            stepNumber: currentStep,
+                            text: textBuffer,
+                            timestamp: Date.now(),
+                        }));
+                        textBuffer = "";
+                    }
+                    stdout += jsonLine(withSession({
+                        type: "structured_response",
+                        stepNumber: currentStep,
+                        timestamp: Date.now(),
+                        taskType: chunk.structuredResponse.taskType,
+                        data: chunk.structuredResponse.data,
+                    }));
+                }
+                break;
+            }
             case "error":
                 stdout += jsonLine(withSession({
                     type: "error",

package/dist/src/headless/output.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createHeadlessJsonlEmitter, isHeadlessOutputFormat, renderHeadlessChunk, renderHeadlessPrelude, } from "./output.js";
+import { createHeadlessJsonlEmitter, createHeadlessTextEmitter, formatStructuredResponseText, isHeadlessOutputFormat, renderHeadlessChunk, renderHeadlessPrelude, } from "./output.js";
 function toolCall(name) {
     return {
         id: "tc-1",
@@ -175,5 +175,65 @@ describe("headless output helpers", () => {
         });
         expectSessionAndTimestamp(parsed, sessionId);
     });
+    // Regression backstop for G5: a respond_* terminal answer arrives ONLY as a
+    // `structured_response` chunk. Both headless renderers used to drop it
+    // (no-op default branch), so `--format text` produced empty stdout and
+    // `--format json` emitted no answer payload on a preamble-free turn.
+    describe("structured_response (respond_* terminal answer)", () => {
+        const generalChunk = {
+            type: "structured_response",
+            structuredResponse: { taskType: "general", data: { response: "The answer." } },
+        };
+        it("renderHeadlessChunk renders the answer to stdout (no longer dropped)", () => {
+            const w = renderHeadlessChunk(generalChunk);
+            expect(w.stdout).toBe("The answer.\n");
+            expect(w.stderr).toBeUndefined();
+        });
+        it("formatStructuredResponseText lays out each taskType as flat text", () => {
+            expect(formatStructuredResponseText({
+                taskType: "analyze",
+                data: { findings: [{ text: "Bug X", evidence: "file:1", severity: "high" }] },
+            })).toBe("[HIGH] Bug X\n  evidence: file:1");
+            expect(formatStructuredResponseText({
+                taskType: "plan",
+                data: { steps: [{ action: "Do A", criterion: "A done", rationale: "because" }] },
+            })).toBe("1. Do A\n   done when: A done\n   why: because");
+            // Unknown taskType falls back to a primary text field, then JSON.
+            expect(formatStructuredResponseText({ taskType: "mystery", data: { summary: "hi" } })).toBe("hi");
+            expect(formatStructuredResponseText({ taskType: "mystery", data: { n: 1 } })).toBe('{\n  "n": 1\n}');
+        });
+        it("text emitter: a structured answer SUPERSEDES leaked preamble content (no duplicate)", () => {
+            const e = createHeadlessTextEmitter();
+            // Model leaks the raw answer as content, then delivers it via respond_*.
+            expect(e.consumeChunk({ type: "content", content: '```json\n{"x":1}\n```' }).stdout).toBeUndefined();
+            const out = e.consumeChunk(generalChunk).stdout;
+            expect(out).toBe("The answer.\n");
+            // Nothing buffered remains to flush — the answer is not printed twice.
+            expect(e.flush().stdout).toBeUndefined();
+        });
+        it("text emitter: a normal content-only turn flushes its buffered answer", () => {
+            const e = createHeadlessTextEmitter();
+            expect(e.consumeChunk({ type: "content", content: "PONG" }).stdout).toBeUndefined();
+            expect(e.consumeChunk({ type: "done" }).stdout).toBeUndefined();
+            expect(e.flush().stdout).toBe("PONG\n");
+        });
+        it("text emitter: tool/error progress still streams to stderr immediately", () => {
+            const e = createHeadlessTextEmitter();
+            const w = e.consumeChunk({ type: "tool_calls", toolCalls: [toolCall("bash")] });
+            expect(w.stderr).toContain("bash");
+            expect(w.stdout).toBeUndefined();
+        });
+        it("json emitter: emits a typed structured_response event carrying the payload", () => {
+            const { consumeChunk } = createHeadlessJsonlEmitter("sess-sr");
+            const out = consumeChunk(generalChunk).stdout ?? "";
+            const events = out
+                .trim()
+                .split("\n")
+                .map((l) => JSON.parse(l));
+            const sr = events.find((ev) => ev.type === "structured_response");
+            expect(sr).toMatchObject({ type: "structured_response", taskType: "general", data: { response: "The answer." } });
+            expectSessionAndTimestamp(sr, "sess-sr");
+        });
+    });
 });
 //# sourceMappingURL=output.test.js.map