muonroi-cli 1.3.4 → 1.4.1

package/src/gsd/complexity.ts

@@ -1,124 +0,0 @@
-/**
- * src/gsd/complexity.ts
- *
- * Heuristic complexity scorer for incoming prompts.
- * Maps a raw user prompt to one of three tiers that drive the GSD directive
- * injected by layer4:
- *
- *   - "heavy"    → multi-file / multi-repo / architectural / "do everything"
- *                  Triggers the full discuss → research → verify → plan → impl → verify flow.
- *   - "standard" → ordinary feature/bugfix work. GSD-quick mindset.
- *   - "quick"    → trivial single-shot tasks (typo, rename, read-and-explain).
- *
- * The scorer is intentionally cheap: regex + length checks. It runs inside the
- * 200ms PIL budget and must never throw.
- */
-
-export type ComplexityTier = "quick" | "standard" | "heavy";
-
-export interface ComplexitySignal {
-  /** Short tag identifying which heuristic fired (e.g. "multi-repo", "wholesale"). */
-  tag: string;
-  /** Weight contributed to the score. Positive = heavier, negative = lighter. */
-  weight: number;
-}
-
-export interface ComplexityResult {
-  tier: ComplexityTier;
-  score: number;
-  signals: ComplexitySignal[];
-}
-
-/** Patterns that strongly suggest a large, multi-step undertaking. */
-const HEAVY_PATTERNS: Array<{ tag: string; pattern: RegExp; weight: number }> = [
-  { tag: "wholesale", pattern: /\b(toàn bộ|all of|entire|whole|everything|tất cả)\b/i, weight: 3 },
-  { tag: "deep-map", pattern: /\b(deep[-\s]?map|repo[-\s]?map|map (the )?(codebase|project|repo))\b/i, weight: 3 },
-  { tag: "redo", pattern: /\b(redo|rewrite|rebuild|migrate (the )?entire|port (the )?(whole|entire))\b/i, weight: 3 },
-  {
-    tag: "from-scratch",
-    pattern: /\b(from[-\s]scratch|greenfield|new project|khởi tạo (project|dự án))\b/i,
-    weight: 2,
-  },
-  { tag: "architecture", pattern: /\b(architect(?:ure)?|system design|design contract|domain model)\b/i, weight: 2 },
-  { tag: "milestone", pattern: /\b(milestone|roadmap|epic|phase \d+|sprint \d+)\b/i, weight: 2 },
-  { tag: "multi-repo", pattern: /\b(multi[-\s]repo|across repos|every repo|all repos|cross[-\s]repo)\b/i, weight: 3 },
-  { tag: "refactor-wide", pattern: /\b(refactor (the )?(entire|whole|all))\b/i, weight: 3 },
-  { tag: "i18n", pattern: /\b(i18n|internationali[sz]e|localization|translation pipeline)\b/i, weight: 2 },
-  { tag: "auth-system", pattern: /\b(auth(entication)? system|sso|oauth flow|rbac)\b/i, weight: 2 },
-  { tag: "many-files", pattern: /\b(\d{2,})\s+(files?|modules?|services?)\b/i, weight: 2 },
-];
-
-/** Patterns that suggest a tiny, one-shot task. */
-const QUICK_PATTERNS: Array<{ tag: string; pattern: RegExp; weight: number }> = [
-  { tag: "typo", pattern: /\b(typo|misspell|spelling)\b/i, weight: -3 },
-  { tag: "rename", pattern: /\b(rename (this|the|a) (var|variable|function|file)|đổi tên)\b/i, weight: -2 },
-  {
-    tag: "read-explain",
-    pattern: /^(what (does|is)|how (does|do|is)|explain|giải thích|là gì|nghĩa là)\b/i,
-    weight: -2,
-  },
-  { tag: "single-line", pattern: /\b(one[-\s]liner|single line|một dòng)\b/i, weight: -2 },
-  { tag: "lookup", pattern: /\b(where is|find the|locate|tìm)\b/i, weight: -1 },
-];
-
-/** Words that, when stacked, indicate orchestration vs single task. */
-const COORDINATION_MARKERS = [
-  /\b(?:and then|sau đó|tiếp theo|after that|followed by)\b/gi,
-  /\b(?:multiple|several|many|nhiều)\b/gi,
-];
-
-const HEAVY_THRESHOLD = 4;
-const QUICK_THRESHOLD = -2;
-const LONG_PROMPT_CHARS = 500;
-const SHORT_PROMPT_CHARS = 60;
-
-export function scoreComplexity(prompt: string): ComplexityResult {
-  const signals: ComplexitySignal[] = [];
-  let score = 0;
-
-  if (!prompt || prompt.trim().length === 0) {
-    return { tier: "quick", score: 0, signals: [{ tag: "empty", weight: 0 }] };
-  }
-
-  for (const { tag, pattern, weight } of HEAVY_PATTERNS) {
-    if (pattern.test(prompt)) {
-      signals.push({ tag, weight });
-      score += weight;
-    }
-  }
-
-  for (const { tag, pattern, weight } of QUICK_PATTERNS) {
-    if (pattern.test(prompt)) {
-      signals.push({ tag, weight });
-      score += weight;
-    }
-  }
-
-  // Coordination words: each match adds 1 point (capped at +3).
-  let coordinationHits = 0;
-  for (const re of COORDINATION_MARKERS) {
-    const matches = prompt.match(re);
-    if (matches) coordinationHits += matches.length;
-  }
-  if (coordinationHits > 0) {
-    const weight = Math.min(coordinationHits, 3);
-    signals.push({ tag: "coordination", weight });
-    score += weight;
-  }
-
-  // Length heuristics.
-  if (prompt.length >= LONG_PROMPT_CHARS) {
-    signals.push({ tag: "long-prompt", weight: 1 });
-    score += 1;
-  } else if (prompt.length <= SHORT_PROMPT_CHARS) {
-    signals.push({ tag: "short-prompt", weight: -1 });
-    score -= 1;
-  }
-
-  let tier: ComplexityTier;
-  if (score >= HEAVY_THRESHOLD) tier = "heavy";
-  else if (score <= QUICK_THRESHOLD) tier = "quick";
-  else tier = "standard";
-
-  return { tier, score, signals };
-}

package/src/gsd/directives.ts

@@ -1,94 +0,0 @@
-/**
- * src/gsd/directives.ts
- *
- * Builds the system-prompt directive block injected by layer4-gsd. The directive
- * is what actually changes the agent's behaviour: it lists the GSD-style steps
- * the agent must take before touching code.
- *
- * Three tiers:
- *   - heavy:    full discuss → research → verify → plan → impl → verify flow,
- *               with mandatory AskUserQuestion + parallel Agent dispatch.
- *   - standard: GSD-quick mindset — short plan, then implement, then verify.
- *   - quick:    minimal hint, run inline.
- *
- * All directive text is English. The agent is responsible for translating
- * user-facing prompts into the user's language at render time.
- */
-
-import type { ComplexityResult } from "./complexity.js";
-import type { GrayAreaQuestion } from "./gray-areas.js";
-import type { GsdPhase } from "./types.js";
-
-export interface DirectiveInput {
-  complexity: ComplexityResult;
-  phase: GsdPhase | null;
-  grayAreas: GrayAreaQuestion[];
-}
-
-export interface DirectiveOutput {
-  text: string;
-  tier: ComplexityResult["tier"];
-  /** True when the directive forbids the agent from acting before clarifying. */
-  blocking: boolean;
-}
-
-const HEADER = "[gsd-native]";
-
-function renderGrayAreas(qs: GrayAreaQuestion[]): string {
-  if (qs.length === 0) return "  (no gray areas detected — confirm the request is fully specified before proceeding)";
-  return qs
-    .map((q, idx) => {
-      const opts = q.options.map((o, i) => `${i === 0 ? "[recommended]" : "[alt]"} ${o}`).join(" / ");
-      return `  ${idx + 1}. (${q.dimension}) ${q.question}\n     options: ${opts}`;
-    })
-    .join("\n");
-}
-
-function buildHeavy(input: DirectiveInput): string {
-  const grayBlock = renderGrayAreas(input.grayAreas);
-  return [
-    `${HEADER} HEAVY task detected (score=${input.complexity.score}, signals=${input.complexity.signals.map((s) => s.tag).join(",") || "none"}).`,
-    "MANDATORY flow before any implementation:",
-    "  1. DISCUSS — call AskUserQuestion with the gray areas below. Each question MUST include the recommended default first so the user can accept by selecting it.",
-    "     Localize question text into the user's language (the language of their last message). Keep options labels English unless they refer to natural-language content.",
-    "  2. RESEARCH + VERIFY — once the user answers, dispatch two Agent calls IN PARALLEL in a single message:",
-    "       (a) a research agent to gather codebase / external facts needed for the task,",
-    "       (b) a verify agent to enumerate acceptance criteria and risks.",
-    "     Wait for both before planning.",
-    "  3. PLAN — produce a short numbered plan grounded in the research + verify outputs. Confirm the plan with the user only if it diverges from their stated intent.",
-    "  4. IMPLEMENT — execute the plan in atomic steps. Prefer parallel Agent dispatch when steps are independent.",
-    "  5. VERIFY — run tests / lints / type checks. Report evidence (command + exit code) before claiming done.",
-    "Gray areas to clarify in step 1:",
-    grayBlock,
-    "Do NOT skip steps. Do NOT begin implementation until step 1 is answered.",
-  ].join("\n");
-}
-
-function buildStandard(input: DirectiveInput): string {
-  const phaseHint = input.phase ? ` (detected phase: ${input.phase})` : "";
-  return [
-    `${HEADER} STANDARD task${phaseHint} — apply GSD-quick mindset.`,
-    "Flow:",
-    "  1. State a 2–3 line plan in your reply.",
-    "  2. Implement directly with the appropriate tools.",
-    "  3. Verify (tests / type-check / quick smoke) and report evidence.",
-    "Skip the discuss/research subagent dance unless a real ambiguity blocks step 1.",
-  ].join("\n");
-}
-
-function buildQuick(input: DirectiveInput): string {
-  const phaseHint = input.phase ? ` phase=${input.phase}` : "";
-  return `${HEADER} QUICK task${phaseHint} — handle inline. No plan, no subagents. Make the smallest correct change and report.`;
-}
-
-export function buildDirective(input: DirectiveInput): DirectiveOutput {
-  switch (input.complexity.tier) {
-    case "heavy":
-      return { text: buildHeavy(input), tier: "heavy", blocking: true };
-    case "standard":
-      return { text: buildStandard(input), tier: "standard", blocking: false };
-    case "quick":
-    default:
-      return { text: buildQuick(input), tier: "quick", blocking: false };
-  }
-}

package/src/gsd/gray-areas.ts

@@ -1,144 +0,0 @@
-/**
- * src/gsd/gray-areas.ts
- *
- * Detects under-specified dimensions in a user prompt and produces a small set
- * of clarifying questions. Each question carries a recommended default so the
- * agent can present them via AskUserQuestion-style flows ("press enter to
- * accept the recommendation").
- *
- * The detector is deliberately conservative: it only flags dimensions the
- * prompt clearly leaves open. False positives on a heavy task are cheap (one
- * extra question); false negatives (skipping a real ambiguity) are expensive.
- */
-
-export type GrayAreaDimension =
-  | "scope"
-  | "target"
-  | "format"
-  | "convention"
-  | "depth"
-  | "audience"
-  | "persona"
-  | "core-features"
-  | "non-functional"
-  | "tech-constraints"
-  | "success-metric"
-  | "cost-tolerance";
-
-export interface GrayAreaQuestion {
-  dimension: GrayAreaDimension;
-  /** Short identifier for the gray area (e.g. "scope-which-repo"). */
-  id: string;
-  /** English question text. The agent localises it for the user at render time. */
-  question: string;
-  /** 2-3 candidate answers; the first is the recommended default. */
-  options: string[];
-  /** Whether an answer is mandatory before proceeding. */
-  isRequired?: boolean;
-}
-
-interface DimensionRule {
-  dimension: GrayAreaDimension;
-  /** If `present` matches the prompt, the dimension is considered specified. */
-  present?: RegExp;
-  /** If `missing` does NOT match, the dimension is considered specified. */
-  missing?: RegExp;
-  /** Question to surface when the dimension is unspecified. */
-  build: (prompt: string) => GrayAreaQuestion;
-}
-
-const SCOPE_TOKENS =
-  /\b(this file|in (src|lib|app)\/|module |package |only |chỉ |duy nhất|specific (file|function))\b/i;
-const TARGET_TOKENS = /\b(repo|repository|project|service|component|module)\b/i;
-const FORMAT_TOKENS = /\b(json|markdown|md|yaml|toml|tsx?|jsx?|csv|html|xml|format)\b/i;
-const CONVENTION_TOKENS = /\b(eslint|prettier|style guide|coding standard|convention|naming)\b/i;
-const DEPTH_TOKENS = /\b(deep|shallow|high[-\s]level|detailed|exhaustive|brief|tóm tắt|chi tiết)\b/i;
-const AUDIENCE_TOKENS =
-  /\b(for (devs?|engineers?|users?|customers?|onboarding|reviewers?)|new joiners?|junior|senior)\b/i;
-
-const RULES: DimensionRule[] = [
-  {
-    dimension: "scope",
-    present: SCOPE_TOKENS,
-    build: () => ({
-      dimension: "scope",
-      id: "scope-breadth",
-      question: "What is the scope of this work — current file, current package, or whole repo?",
-      options: ["current package only", "single file", "entire repository"],
-    }),
-  },
-  {
-    dimension: "target",
-    present: TARGET_TOKENS,
-    build: () => ({
-      dimension: "target",
-      id: "target-which",
-      question: "Which repo/service/module is the target?",
-      options: ["the current working directory", "infer from recent context", "ask before acting"],
-    }),
-  },
-  {
-    dimension: "format",
-    present: FORMAT_TOKENS,
-    build: () => ({
-      dimension: "format",
-      id: "format-output",
-      question: "What output format should the deliverable use?",
-      options: ["match existing project conventions", "Markdown document", "structured JSON"],
-    }),
-  },
-  {
-    dimension: "convention",
-    present: CONVENTION_TOKENS,
-    build: () => ({
-      dimension: "convention",
-      id: "convention-style",
-      question: "Follow the project's existing conventions, or introduce new ones?",
-      options: ["follow existing conventions", "propose improvements then confirm", "introduce new conventions"],
-    }),
-  },
-  {
-    dimension: "depth",
-    present: DEPTH_TOKENS,
-    build: () => ({
-      dimension: "depth",
-      id: "depth-level",
-      question: "How deep should the analysis/output go?",
-      options: ["balanced — key facts plus rationale", "high-level summary only", "exhaustive deep dive"],
-    }),
-  },
-  {
-    dimension: "audience",
-    present: AUDIENCE_TOKENS,
-    build: () => ({
-      dimension: "audience",
-      id: "audience-reader",
-      question: "Who is the primary reader/user of this output?",
-      options: ["future Claude/agent sessions", "human engineers on this team", "external stakeholders"],
-    }),
-  },
-];
-
-const MAX_QUESTIONS = 4;
-
-export interface GrayAreaResult {
-  questions: GrayAreaQuestion[];
-  /** Total dimensions considered. Useful for tests and metrics. */
-  evaluated: number;
-}
-
-export function detectGrayAreas(prompt: string): GrayAreaResult {
-  if (!prompt || prompt.trim().length === 0) {
-    return { questions: [], evaluated: 0 };
-  }
-
-  const questions: GrayAreaQuestion[] = [];
-  for (const rule of RULES) {
-    const specified = (rule.present && rule.present.test(prompt)) || (rule.missing && !rule.missing.test(prompt));
-    if (!specified) {
-      questions.push(rule.build(prompt));
-      if (questions.length >= MAX_QUESTIONS) break;
-    }
-  }
-  return { questions, evaluated: RULES.length };
-}

package/src/gsd/index.ts

@@ -1 +0,0 @@
-export { detectGsdPhase, GSD_PHASES, type GsdPhase, isGsdPhase } from "./types.js";

package/src/gsd/types.ts

@@ -1,49 +0,0 @@
-export const GSD_PHASES = ["discuss", "plan", "execute", "verify", "review"] as const;
-
-export type GsdPhase = (typeof GSD_PHASES)[number];
-
-export type WorkflowKind = "task" | "product";
-
-export function isGsdPhase(value: string): value is GsdPhase {
-  return (GSD_PHASES as readonly string[]).includes(value);
-}
-
-const PHASE_KEYWORDS: Record<GsdPhase, string[]> = {
-  discuss: ["discuss", "brainstorm", "explore", "think about", "consider"],
-  plan: ["plan", "design", "architect", "outline", "roadmap"],
-  execute: ["execute", "implement", "build", "create", "write", "code", "develop"],
-  verify: ["verify", "validate", "test", "check", "confirm", "ensure"],
-  review: ["review", "audit", "inspect", "examine", "evaluate"],
-};
-
-const PHASE_PRIORITY: Record<GsdPhase, number> = {
-  execute: 5,
-  verify: 4,
-  discuss: 3,
-  plan: 2,
-  review: 1,
-};
-
-export function detectGsdPhase(text: string): GsdPhase | null {
-  const lower = text.toLowerCase();
-
-  let bestPhase: GsdPhase | null = null;
-  let bestPos = Infinity;
-  let bestPriority = -1;
-
-  for (const [phase, keywords] of Object.entries(PHASE_KEYWORDS) as [GsdPhase, string[]][]) {
-    for (const kw of keywords) {
-      const pos = lower.indexOf(kw);
-      if (pos === -1) continue;
-
-      const priority = PHASE_PRIORITY[phase];
-      if (pos < bestPos || (pos === bestPos && priority > bestPriority)) {
-        bestPhase = phase;
-        bestPos = pos;
-        bestPriority = priority;
-      }
-    }
-  }
-
-  return bestPhase;
-}

package/src/headless/__tests__/council-answers.test.ts

@@ -1,266 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { CouncilQuestionData } from "../../types/index.js";
-import { createCouncilAutoAnswerer, handleCouncilChunk, parseCouncilAnswersFile } from "../council-answers.js";
-
-function q(over: Partial<CouncilQuestionData>): CouncilQuestionData {
-  return {
-    questionId: "qid",
-    question: "?",
-    isRequired: false,
-    ...over,
-  };
-}
-
-describe("parseCouncilAnswersFile", () => {
-  it("parses a valid object with phase queues + preflightApprove", () => {
-    const out = parseCouncilAnswersFile(
-      JSON.stringify({
-        clarify: ["python", "mongo"],
-        "post-debate": ["generate_plan"],
-        preflightApprove: false,
-      }),
-    );
-    expect(out.clarify).toEqual(["python", "mongo"]);
-    expect(out["post-debate"]).toEqual(["generate_plan"]);
-    expect(out.preflightApprove).toBe(false);
-  });
-
-  it("rejects non-object root", () => {
-    expect(() => parseCouncilAnswersFile(JSON.stringify(["x"]))).toThrow(/object/);
-    expect(() => parseCouncilAnswersFile(JSON.stringify(42))).toThrow(/object/);
-  });
-
-  it("rejects non-string entries in a phase queue", () => {
-    expect(() => parseCouncilAnswersFile(JSON.stringify({ clarify: [1, 2] }))).toThrow(/clarify/);
-  });
-
-  it("rejects non-boolean preflightApprove", () => {
-    expect(() => parseCouncilAnswersFile(JSON.stringify({ preflightApprove: "yes" }))).toThrow(/preflightApprove/);
-  });
-
-  it("accepts an empty object", () => {
-    expect(parseCouncilAnswersFile("{}")).toEqual({});
-  });
-});
-
-describe("createCouncilAutoAnswerer", () => {
-  it("returns null when neither enabled nor file is provided", () => {
-    expect(createCouncilAutoAnswerer({ enabled: false })).toBeNull();
-  });
-
-  it("--yes alone picks defaultIndex value", () => {
-    const a = createCouncilAutoAnswerer({ enabled: true });
-    expect(a).not.toBeNull();
-    const answer = a!.answerQuestion(
-      q({
-        phase: "post-debate",
-        defaultIndex: 1,
-        options: [
-          { label: "A", value: "a", kind: "choice" },
-          { label: "B", value: "b", kind: "choice" },
-        ],
-      }),
-    );
-    expect(answer).toBe("b");
-  });
-
-  it("falls back to first option when defaultIndex is out of range", () => {
-    const a = createCouncilAutoAnswerer({ enabled: true });
-    const answer = a!.answerQuestion(
-      q({
-        phase: "post-debate",
-        defaultIndex: 99,
-        options: [
-          { label: "A", value: "a", kind: "choice" },
-          { label: "B", value: "b", kind: "choice" },
-        ],
-      }),
-    );
-    expect(answer).toBe("a");
-  });
-
-  it("returns empty string for freetext questions with no options", () => {
-    const a = createCouncilAutoAnswerer({ enabled: true });
-    expect(a!.answerQuestion(q({ phase: "clarify" }))).toBe("");
-  });
-
-  it("scripted answers consume FIFO per phase", () => {
-    const a = createCouncilAutoAnswerer({
-      enabled: false,
-      file: { clarify: ["first", "second"] },
-    });
-    expect(a!.answerQuestion(q({ phase: "clarify" }))).toBe("first");
-    expect(a!.answerQuestion(q({ phase: "clarify" }))).toBe("second");
-    // Queue exhausted → fall back to default (empty string for freetext).
-    expect(a!.answerQuestion(q({ phase: "clarify" }))).toBe("");
-  });
-
-  it("scripted queue for one phase does not bleed into another", () => {
-    const a = createCouncilAutoAnswerer({
-      enabled: false,
-      file: { clarify: ["c1"], "post-debate": ["pd1"] },
-    });
-    expect(a!.answerQuestion(q({ phase: "post-debate" }))).toBe("pd1");
-    expect(a!.answerQuestion(q({ phase: "clarify" }))).toBe("c1");
-  });
-
-  it("preflight approval defaults to true", () => {
-    const a = createCouncilAutoAnswerer({ enabled: true });
-    expect(a!.approvePreflight()).toBe(true);
-  });
-
-  it("preflight approval honors preflightApprove: false", () => {
-    const a = createCouncilAutoAnswerer({
-      enabled: false,
-      file: { preflightApprove: false },
-    });
-    expect(a!.approvePreflight()).toBe(false);
-  });
-
-  it("preserves caller's file by deep-copying queues", () => {
-    const file = { clarify: ["a", "b"] };
-    const a = createCouncilAutoAnswerer({ enabled: false, file });
-    a!.answerQuestion(q({ phase: "clarify" }));
-    // The caller's queue must remain intact.
-    expect(file.clarify).toEqual(["a", "b"]);
-  });
-});
-
-describe("handleCouncilChunk (interception wiring)", () => {
-  function makeSink() {
-    return {
-      respondToQuestion: vi.fn(),
-      respondToPreflight: vi.fn(),
-    };
-  }
-
-  it("returns null and is a no-op when answerer is null", () => {
-    const sink = makeSink();
-    const out = handleCouncilChunk({ type: "council_question", councilQuestion: q({ phase: "clarify" }) }, null, sink);
-    expect(out).toBeNull();
-    expect(sink.respondToQuestion).not.toHaveBeenCalled();
-  });
-
-  it("returns null for non-askcard chunks", () => {
-    const sink = makeSink();
-    const a = createCouncilAutoAnswerer({ enabled: true });
-    const out = handleCouncilChunk({ type: "content" }, a, sink);
-    expect(out).toBeNull();
-    expect(sink.respondToQuestion).not.toHaveBeenCalled();
-    expect(sink.respondToPreflight).not.toHaveBeenCalled();
-  });
-
-  it("calls respondToQuestion with the resolved answer for a clarify chunk", () => {
-    const sink = makeSink();
-    const a = createCouncilAutoAnswerer({
-      enabled: false,
-      file: { clarify: ["mongo"] },
-    });
-    const audit = handleCouncilChunk(
-      {
-        type: "council_question",
-        councilQuestion: q({ phase: "clarify", questionId: "q-1" }),
-      },
-      a,
-      sink,
-    );
-    expect(sink.respondToQuestion).toHaveBeenCalledWith("q-1", "mongo");
-    expect(audit).toContain("clarify → mongo");
-  });
-
-  it("calls respondToQuestion with defaultIndex value when --yes only", () => {
-    const sink = makeSink();
-    const a = createCouncilAutoAnswerer({ enabled: true });
-    handleCouncilChunk(
-      {
-        type: "council_question",
-        councilQuestion: q({
-          phase: "post-debate",
-          questionId: "q-2",
-          defaultIndex: 0,
-          options: [
-            { label: "Continue", value: "continue", kind: "choice" },
-            { label: "Stop", value: "stop", kind: "choice" },
-          ],
-        }),
-      },
-      a,
-      sink,
-    );
-    expect(sink.respondToQuestion).toHaveBeenCalledWith("q-2", "continue");
-  });
-
-  it("approves preflight chunks by default", () => {
-    const sink = makeSink();
-    const a = createCouncilAutoAnswerer({ enabled: true });
-    const audit = handleCouncilChunk({ type: "council_preflight", councilPreflight: { preflightId: "pf-1" } }, a, sink);
-    expect(sink.respondToPreflight).toHaveBeenCalledWith("pf-1", true);
-    expect(audit).toContain("approve");
-  });
-
-  it("rejects preflight when file says preflightApprove: false", () => {
-    const sink = makeSink();
-    const a = createCouncilAutoAnswerer({
-      enabled: false,
-      file: { preflightApprove: false },
-    });
-    handleCouncilChunk({ type: "council_preflight", councilPreflight: { preflightId: "pf-2" } }, a, sink);
-    expect(sink.respondToPreflight).toHaveBeenCalledWith("pf-2", false);
-  });
-
-  it("replays the 1a8fb4be3bc3 session via a scripted file", () => {
-    // Simulates the 3 clarify answers from chat-export-1a8fb4be3bc3.txt
-    // plus a typical research-skip "no" + post-debate "continue" + preflight approve.
-    const sink = makeSink();
-    const a = createCouncilAutoAnswerer({
-      enabled: true,
-      file: {
-        clarify: [
-          "Browser extension (Chrome/Brave/Edge compatible)",
-          "Google Cloud Translation API (paid, reliable)",
-          "Auto-show tooltip/popup immediately on text highlight",
-        ],
-        // FIFO across all post-debate askcards: research-skip → "no", then post-debate continue
-        "post-debate": ["no", "continue"],
-      },
-    });
-    const order: string[] = [];
-    const fakeStream: Array<{
-      type: string;
-      councilQuestion?: CouncilQuestionData;
-      councilPreflight?: { preflightId: string };
-    }> = [
-      { type: "council_question", councilQuestion: q({ phase: "clarify", questionId: "c1" }) },
-      { type: "council_question", councilQuestion: q({ phase: "clarify", questionId: "c2" }) },
-      { type: "council_question", councilQuestion: q({ phase: "clarify", questionId: "c3" }) },
-      // research skip → no scripted answer for "post-debate" yet; --yes default kicks in (option 0 = "no")
-      {
-        type: "council_question",
-        councilQuestion: q({
-          phase: "post-debate",
-          questionId: "research-skip",
-          defaultIndex: 0,
-          options: [
-            { label: "No — run research", value: "no", kind: "choice" },
-            { label: "Yes — skip", value: "yes", kind: "choice" },
-          ],
-        }),
-      },
-      { type: "council_preflight", councilPreflight: { preflightId: "pf-1" } },
-      // post-debate scripted "continue"
-      { type: "council_question", councilQuestion: q({ phase: "post-debate", questionId: "pd-1" }) },
-    ];
-    for (const chunk of fakeStream) {
-      handleCouncilChunk(chunk, a, sink);
-    }
-    for (const call of sink.respondToQuestion.mock.calls) order.push(call[1]);
-    expect(order).toEqual([
-      "Browser extension (Chrome/Brave/Edge compatible)",
-      "Google Cloud Translation API (paid, reliable)",
-      "Auto-show tooltip/popup immediately on text highlight",
-      "no",
-      "continue",
-    ]);
-    expect(sink.respondToPreflight).toHaveBeenCalledWith("pf-1", true);
-  });
-});