muonroi-cli 1.3.4 → 1.4.1

package/src/council/__tests__/tool-trace.test.ts

@@ -1,152 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { CouncilLLM, ToolTraceEmitter } from "../types.js";
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-/**
- * Build a minimal CouncilLLM that wraps a provided debate/research impl
- * with generate() always returning "".
- */
-function makeLLM(overrides: Partial<CouncilLLM>): CouncilLLM {
-  return {
-    async generate() {
-      return "";
-    },
-    async research() {
-      return "";
-    },
-    async debate() {
-      return { text: "", toolCalls: [] };
-    },
-    ...overrides,
-  };
-}
-
-// ── Test 1: debate() calls persistTrace once per tool call ───────────────────
-
-describe("[Council Tool Trace] — llm.debate() (CQ-22)", () => {
-  it("Test 1: calls persistTrace once per tool call with string starting '[Council Tool Trace]'", async () => {
-    // We test createCouncilLLM indirectly. Because the real createCouncilLLM
-    // calls real LLM providers, we instead test that the debate() implementation
-    // emits traces. We do this by importing the types and testing debate.ts
-    // integration with a mock that accepts persistTrace.
-    //
-    // For unit testing the emitToolTrace helper and the debate() wiring,
-    // we test through the CouncilLLM interface. The real impl is tested via
-    // debate.ts integration (below). Here we verify types compile correctly.
-
-    const traces: string[] = [];
-    const persistTrace: ToolTraceEmitter = (t) => traces.push(t);
-
-    // After implementation, CouncilLLM.debate() accepts persistTrace as 5th arg.
-    // We call a mock that validates the signature compiles.
-    const llm = makeLLM({
-      async debate(_modelId, _system, _prompt, _signal, _persistTrace) {
-        // Simulate tool call emission via persistTrace
-        _persistTrace?.("[Council Tool Trace] tool=bash args={} result=ok");
-        return { text: "response", toolCalls: [{ toolName: "bash", result: "ok" }] };
-      },
-    });
-
-    await llm.debate("m1", "sys", "prompt", undefined, persistTrace);
-    expect(traces).toHaveLength(1);
-    expect(traces[0]).toMatch(/^\[Council Tool Trace\]/);
-  });
-
-  it("Test 2: args truncated to <= 2048 chars in trace string", async () => {
-    const traces: string[] = [];
-    const persistTrace: ToolTraceEmitter = (t) => traces.push(t);
-
-    // Import the actual createCouncilLLM won't work without real providers.
-    // Instead, test the truncation logic through a mock that mirrors the
-    // emitToolTrace helper behavior.
-    //
-    // We import the helper indirectly by testing the createCouncilLLM output
-    // when debate is called. Since we can't call real LLM in unit tests,
-    // we verify via the mock CouncilLLM interface accepting the persistTrace param.
-    //
-    // The real truncation test: import emitToolTrace or test via debate.ts.
-    // We test by creating a mock debate() that calls persistTrace with a long args string
-    // and verifying trace length is bounded.
-
-    const longArgs = "a".repeat(3000);
-    const llm = makeLLM({
-      async debate(_m, _s, _p, _sig, pt) {
-        // Simulate what emitToolTrace does with 2048 truncation
-        const truncated = longArgs.length > 2048 ? longArgs.slice(0, 2048) + "…[truncated]" : longArgs;
-        pt?.(`[Council Tool Trace] tool=bash args=${truncated} result=ok`);
-        return { text: "", toolCalls: [{ toolName: "bash" }] };
-      },
-    });
-
-    await llm.debate("m1", "s", "p", undefined, persistTrace);
-    expect(traces).toHaveLength(1);
-    // args portion should be truncated: "a".repeat(2048) + "…[truncated]" = 2048 + 13 chars for args value
-    const traceArgs = traces[0].match(/args=(.+?) result=/)?.[1] ?? "";
-    expect(traceArgs.length).toBeLessThanOrEqual(2048 + "…[truncated]".length);
-  });
-
-  it("Test 3: result truncated to <= 2048 chars", async () => {
-    const traces: string[] = [];
-    const persistTrace: ToolTraceEmitter = (t) => traces.push(t);
-    const longResult = "x".repeat(3000);
-
-    const llm = makeLLM({
-      async debate(_m, _s, _p, _sig, pt) {
-        const truncated = longResult.length > 2048 ? longResult.slice(0, 2048) + "…[truncated]" : longResult;
-        pt?.(`[Council Tool Trace] tool=bash args={} result=${truncated}`);
-        return { text: "", toolCalls: [{ toolName: "bash", result: longResult }] };
-      },
-    });
-
-    await llm.debate("m1", "s", "p", undefined, persistTrace);
-    expect(traces).toHaveLength(1);
-    const resultPart = traces[0].split("result=")[1] ?? "";
-    expect(resultPart.length).toBeLessThanOrEqual(2048 + "…[truncated]".length);
-  });
-
-  it("Test 4: research() calls persistTrace once per tool call", async () => {
-    const traces: string[] = [];
-    const persistTrace: ToolTraceEmitter = (t) => traces.push(t);
-
-    const llm = makeLLM({
-      async research(_m, _topic, _ctx, _sig, pt) {
-        pt?.("[Council Tool Trace] tool=read_file args={} result=contents");
-        return "findings";
-      },
-    });
-
-    await llm.research("m1", "topic", "ctx", undefined, persistTrace);
-    expect(traces).toHaveLength(1);
-    expect(traces[0]).toMatch(/^\[Council Tool Trace\]/);
-  });
-
-  it("Test 5: debate() and research() work without error when persistTrace is undefined", async () => {
-    const llm = makeLLM({
-      async debate(_m, _s, _p, _sig, pt) {
-        pt?.("[Council Tool Trace] tool=bash args={} result=ok");
-        return { text: "ok", toolCalls: [] };
-      },
-      async research(_m, _t, _c, _sig, pt) {
-        pt?.("[Council Tool Trace] tool=bash args={} result=ok");
-        return "ok";
-      },
-    });
-
-    // Should not throw
-    await expect(llm.debate("m1", "s", "p")).resolves.toBeDefined();
-    await expect(llm.research("m1", "t", "c")).resolves.toBeDefined();
-  });
-});
-
-// ── Integration: verify types are correct ────────────────────────────────────
-
-describe("ToolTraceEmitter type export", () => {
-  it("ToolTraceEmitter is exported from types.ts and is a function type", () => {
-    // This test verifies the type exists at runtime by checking we can assign it.
-    const emitter: ToolTraceEmitter = (text: string) => {
-      void text;
-    };
-    expect(typeof emitter).toBe("function");
-  });
-});

package/src/council/__tests__/types-contract.test.ts

@@ -1,88 +0,0 @@
-/**
- * Type-level contract tests for Phase 15 Plan 01:
- * - LeaderEvaluation gains evidenceDensity and disagreementResolved optional fields
- * - CouncilLLM gains debate() method signature
- *
- * These are compile-time-only assertions. If the file compiles cleanly, the tests pass.
- * Runtime assertions are used only where TypeScript's structural typing makes them necessary.
- */
-
-import { describe, expect, it } from "vitest";
-import type { CouncilLLM, LeaderEvaluation } from "../types.js";
-
-describe("LeaderEvaluation type contract", () => {
-  it("accepts evidenceDensity as optional number", () => {
-    const evaluation: LeaderEvaluation = {
-      allCriteriaMet: false,
-      criteriaStatus: [],
-      unresolvedPoints: [],
-      needsResearch: false,
-      shouldContinue: true,
-      reason: "test",
-      evidenceDensity: 0.25,
-    };
-    expect(evaluation.evidenceDensity).toBe(0.25);
-  });
-
-  it("accepts disagreementResolved as optional number", () => {
-    const evaluation: LeaderEvaluation = {
-      allCriteriaMet: true,
-      criteriaStatus: [],
-      unresolvedPoints: [],
-      needsResearch: false,
-      shouldContinue: false,
-      reason: "all resolved",
-      disagreementResolved: 3,
-    };
-    expect(evaluation.disagreementResolved).toBe(3);
-  });
-
-  it("remains backward compatible — both optional fields absent", () => {
-    const evaluation: LeaderEvaluation = {
-      allCriteriaMet: true,
-      criteriaStatus: [{ criterion: "c1", met: true, evidence: "ok" }],
-      unresolvedPoints: [],
-      needsResearch: false,
-      shouldContinue: false,
-      reason: "done",
-    };
-    // No evidenceDensity or disagreementResolved — must compile fine
-    expect(evaluation.evidenceDensity).toBeUndefined();
-    expect(evaluation.disagreementResolved).toBeUndefined();
-  });
-});
-
-describe("CouncilLLM.debate() method contract", () => {
-  it("debate() method is part of the CouncilLLM interface", () => {
-    // Structural check: create a minimal implementation that satisfies the interface.
-    // If CouncilLLM does not have debate(), this will cause a compile error.
-    const mockLLM: CouncilLLM = {
-      generate: async () => "text",
-      research: async () => "research",
-      debate: async (_modelId, _system, _prompt, _signal) => ({
-        text: "debate response",
-        toolCalls: [{ toolName: "webSearch", result: { url: "https://example.com" } }],
-      }),
-    };
-    expect(typeof mockLLM.debate).toBe("function");
-  });
-
-  it("debate() returns correct shape — text and toolCalls array", async () => {
-    const mockLLM: CouncilLLM = {
-      generate: async () => "",
-      research: async () => "",
-      debate: async () => ({
-        text: "grounded response",
-        toolCalls: [
-          { toolName: "bash", result: "output" },
-          { toolName: "grep" }, // result is optional
-        ],
-      }),
-    };
-    const result = await mockLLM.debate("model", "system", "prompt");
-    expect(result.text).toBe("grounded response");
-    expect(result.toolCalls).toHaveLength(2);
-    expect(result.toolCalls[0].toolName).toBe("bash");
-    expect(result.toolCalls[1].result).toBeUndefined();
-  });
-});

package/src/council/clarifier.ts

@@ -1,409 +0,0 @@
-import type { GrayAreaQuestion } from "../gsd/gray-areas.js";
-import type { CouncilQuestionOption, StreamChunk } from "../types/index.js";
-import { pickCouncilTaskModel } from "./leader.js";
-import { tracedGenerate } from "./llm.js";
-import { phaseDone, phaseError, phaseStart } from "./phase-events.js";
-import { buildClarificationPrompt, buildSpecSynthesisPrompt } from "./prompts.js";
-import type { ClarifiedSpec, CouncilLLM, QuestionResponder } from "./types.js";
-
-/**
- * Convert a PIL gray-area question into the clarifier's round-question shape.
- * The first option is treated as the recommended default (matches the
- * convention used by detectGrayAreas).
- */
-function grayAreaToRoundQuestion(g: GrayAreaQuestion): {
-  question: string;
-  why: string;
-  suggestions: string[];
-  recommended: string;
-  isRequired: boolean;
-} {
-  return {
-    question: g.question,
-    why: `Gray area: ${g.dimension} dimension is unspecified.`,
-    suggestions: g.options,
-    recommended: g.options[0] ?? "",
-    isRequired: true,
-  };
-}
-
-export interface ClarifyOptionsResult {
-  options: CouncilQuestionOption[];
-  /**
-   * Index of the agent's recommended option, or undefined when the agent did
-   * not provide a recommendation. The card uses this to decide whether to
-   * show the "(Recommended)" tag — it stays hidden when undefined.
-   */
-  defaultIndex?: number;
-}
-
-/**
- * Convert legacy `suggestions: string[]` into the new options schema with
- * standard "Type something" / "Chat about this" escape-hatches appended.
- *
- * The card UI uses `kind` to decide how to handle each option:
- *  - choice   → submit value as-is
- *  - freetext → open inline text input
- *  - chat     → pause council and let user discuss before answering
- *
- * If `recommended` is provided AND matches one of the suggestions, the
- * returned `defaultIndex` points to it. Otherwise `defaultIndex` is omitted
- * so the UI knows to suppress the "(Recommended)" tag.
- */
-export function buildClarifyOptions(suggestions: string[] | undefined, recommended?: string): ClarifyOptionsResult {
-  const choices: CouncilQuestionOption[] = (suggestions ?? [])
-    .filter((s) => typeof s === "string" && s.trim().length > 0)
-    .map((s) => ({ label: s.trim(), value: s.trim(), kind: "choice" as const }));
-
-  const options: CouncilQuestionOption[] = [
-    ...choices,
-    {
-      label: "Type something",
-      description: "Nhập câu trả lời tự do",
-      value: "",
-      kind: "freetext" as const,
-    },
-    {
-      label: "Chat about this",
-      description: "Thảo luận thêm trước khi trả lời",
-      value: "",
-      kind: "chat" as const,
-    },
-  ];
-
-  let defaultIndex: number | undefined;
-  if (typeof recommended === "string" && recommended.trim().length > 0) {
-    const target = recommended.trim().toLowerCase();
-    const idx = choices.findIndex((opt) => opt.value.toLowerCase() === target);
-    if (idx !== -1) defaultIndex = idx;
-  }
-
-  return { options, defaultIndex };
-}
-
-export async function* runClarification(
-  topic: string,
-  leaderModelId: string,
-  conversationContext: string,
-  respondToQuestion: QuestionResponder,
-  llm: CouncilLLM,
-  signal?: AbortSignal,
-  seedQuestions?: GrayAreaQuestion[],
-  maxRounds?: number,
-  /**
-   * Optional pre-filled answers keyed by seed-question id. When the loop's
-   * discover phase has already proven a dimension from the project (e.g.
-   * tech-constraints from package.json), the matching seed question is
-   * skipped: its answer is appended to allQA without prompting the user, and
-   * a confirmation chunk is emitted instead.
-   */
-  prefillAnswers?: Map<string, string>,
-  /**
-   * When true, clarification question generation and spec synthesis run on
-   * a cheaper tier model on the same provider as the leader. Falls back to
-   * the leader model if no cheaper model is cataloged. Default false.
-   */
-  costAware = false,
-): AsyncGenerator<StreamChunk, ClarifiedSpec, unknown> {
-  const max = typeof maxRounds === "number" && maxRounds > 0 ? maxRounds : 3;
-  const allQA: Array<{ id?: string; question: string; answer: string }> = [];
-
-  const phaseStartedAt = Date.now();
-  yield phaseStart({ phaseId: "phase:clarification", kind: "clarification", label: "Clarification" });
-
-  const seeded = (seedQuestions ?? []).map(grayAreaToRoundQuestion);
-
-  for (let round = 0; round < max; round++) {
-    const useSeed = round === 0 && seeded.length > 0;
-    const roundId = `phase:clarification-round-${round + 1}`;
-    const roundStart = Date.now();
-    yield phaseStart({
-      phaseId: roundId,
-      kind: "clarification_round",
-      label: useSeed ? `Clarification round ${round + 1} (PIL-seeded)` : `Clarification round ${round + 1}`,
-    });
-
-    let questions: Array<{
-      id?: string;
-      question: string;
-      why: string;
-      suggestions?: string[];
-      recommended?: string;
-      isRequired: boolean;
-    }>;
-
-    if (useSeed) {
-      questions = (seedQuestions ?? []).map((g) => ({
-        id: g.id,
-        ...grayAreaToRoundQuestion(g),
-      }));
-    } else {
-      const { system, prompt } = buildClarificationPrompt(
-        topic,
-        conversationContext,
-        allQA.length > 0 ? allQA : undefined,
-      );
-
-      let questionsRaw: string;
-      try {
-        const clarifyModel = pickCouncilTaskModel("clarify_questions", leaderModelId, costAware);
-        questionsRaw = yield* tracedGenerate(llm, {
-          phase: "clarify",
-          label: `Generating clarification questions (round ${round + 1})`,
-          modelId: clarifyModel,
-          system,
-          prompt,
-          maxTokens: 2048,
-        });
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        yield phaseError({
-          phaseId: roundId,
-          kind: "clarification_round",
-          label: `Clarification round ${round + 1}`,
-          startedAt: roundStart,
-          errorMessage: msg,
-        });
-        yield { type: "content", content: `[Clarification error: ${msg}]\n` };
-        break;
-      }
-
-      try {
-        const match = questionsRaw.match(/\[[\s\S]*\]/);
-        questions = match ? JSON.parse(match[0]) : [];
-      } catch {
-        questions = [];
-      }
-    }
-
-    if (questions.length === 0) {
-      yield phaseDone({
-        phaseId: roundId,
-        kind: "clarification_round",
-        label: `Clarification round ${round + 1}`,
-        startedAt: roundStart,
-        detail: "no further clarification needed",
-      });
-      break;
-    }
-
-    yield phaseDone({
-      phaseId: roundId,
-      kind: "clarification_round",
-      label: `Clarification round ${round + 1}`,
-      startedAt: roundStart,
-      detail: `${questions.length} question${questions.length === 1 ? "" : "s"}`,
-    });
-
-    for (const q of questions) {
-      // Skip seed questions whose dimension was proven by project discovery.
-      // The auto-filled answer is recorded as a normal Q&A so synthesizeSpec
-      // and the resolved-map see it as answered.
-      if (q.id && prefillAnswers?.has(q.id)) {
-        const answer = prefillAnswers.get(q.id)!;
-        allQA.push({ id: q.id, question: q.question, answer });
-        yield {
-          type: "content",
-          content: `\n**${q.question}**\n  ↳ _${answer}_ (auto-filled from project)\n`,
-        };
-        continue;
-      }
-
-      const questionId = crypto.randomUUID();
-      const { options, defaultIndex } = buildClarifyOptions(q.suggestions, q.recommended);
-
-      yield {
-        type: "council_question" as StreamChunk["type"],
-        content: `**${q.question}**\n${q.why ? `> ${q.why}` : ""}`,
-        councilQuestion: {
-          questionId,
-          phase: "clarify",
-          question: q.question,
-          context: q.why,
-          suggestions: q.suggestions,
-          options,
-          isRequired: q.isRequired,
-          defaultIndex,
-        },
-      };
-
-      const answer = await respondToQuestion(questionId);
-      allQA.push({ id: q.id, question: q.question, answer });
-      yield { type: "content", content: `\n  ↳ ${answer}\n` };
-    }
-  }
-
-  yield phaseDone({
-    phaseId: "phase:clarification",
-    kind: "clarification",
-    label: "Clarification",
-    startedAt: phaseStartedAt,
-    detail: allQA.length > 0 ? `${allQA.length} Q&A` : "no clarification needed",
-  });
-
-  const spec = yield* synthesizeSpec(topic, conversationContext, allQA, leaderModelId, llm, costAware);
-
-  yield {
-    type: "council_info_card",
-    councilInfoCard: {
-      title: "Clarified Spec",
-      sections: [
-        { heading: "Problem", body: spec.problemStatement },
-        {
-          heading: "Constraints",
-          body: spec.constraints.map((c) => `- ${c}`).join("\n") || "- (none)",
-        },
-        {
-          heading: "Success Criteria",
-          body: spec.successCriteria.map((c) => `- ${c}`).join("\n"),
-        },
-        { heading: "Scope", body: spec.scope || "(unspecified)" },
-      ],
-    },
-  };
-
-  return spec;
-}
-
-export function buildSpecFromTopic(topic: string, conversationContext: string): ClarifiedSpec {
-  return {
-    problemStatement: topic,
-    constraints: [],
-    successCriteria: [`Address the topic: ${topic.slice(0, 100)}`],
-    scope: "Determined by conversation context",
-    rawQA: [],
-  };
-}
-
-/**
- * Generate richer success criteria from the topic alone when clarifier returned
- * no questions. The single-criterion fallback ("Address the topic: …") made
- * leader-eval meaningless: "1/1 criteria met" trivially trips on round 1 even
- * for complex topics. Session ea13da132dec hit this because clarifier returned
- * [] and the spec had only one auto-criterion → leader had nothing real to grade.
- *
- * We LLM-extract criteria/constraints/scope from the topic when QA is empty.
- * Falls back to the original buildSpecFromTopic if the LLM call fails.
- */
-async function* inferSpecFromTopicOnly(
-  topic: string,
-  conversationContext: string,
-  leaderModelId: string,
-  llm: CouncilLLM,
-  costAware: boolean,
-): AsyncGenerator<StreamChunk, ClarifiedSpec, unknown> {
-  const system =
-    `You are extracting an implicit specification from a short topic statement. ` +
-    `The user did not answer clarification questions, but the topic itself often ` +
-    `implies scope, criteria, and constraints. Tease them out.\n\n` +
-    `Output ONLY a JSON object (no markdown, no preamble):\n` +
-    `{\n` +
-    `  "problemStatement": "1-2 sentence problem statement in the user's language",\n` +
-    `  "constraints": ["constraint 1", "constraint 2"],\n` +
-    `  "successCriteria": ["criterion 1", "criterion 2", "criterion 3"],\n` +
-    `  "scope": "what is in and out of scope, in 1-2 sentences"\n` +
-    `}\n\n` +
-    `Rules:\n` +
-    `- successCriteria MUST have AT LEAST 3 entries. These should be observable, testable ` +
-    `outcomes — not "address the topic". For a feature topic, criteria look like ` +
-    `"User can do X in under Y", "System supports Z platform", "Performance budget P ms".\n` +
-    `- constraints should include any explicit limits the topic mentions (platforms, languages, ` +
-    `vendors). If no constraints are explicit, infer 1-2 likely-implicit ones (e.g. "Must work ` +
-    `offline" for a desktop app topic, "Must respect Manifest V3" for a Chrome extension).\n` +
-    `- scope should name 1 thing in-scope and 1 thing OUT-of-scope.\n` +
-    `- Write all fields in the user's language (detected from the topic).`;
-  const prompt = `## Topic\n${topic}\n\n` + (conversationContext ? `## Context\n${conversationContext}\n` : "");
-
-  try {
-    const synthModel = pickCouncilTaskModel("spec_synthesis", leaderModelId, costAware);
-    const raw = yield* tracedGenerate(llm, {
-      phase: "synthesis",
-      label: "Inferring spec from topic (no clarification answers)",
-      modelId: synthModel,
-      system,
-      prompt,
-      maxTokens: 1024,
-    });
-    const match = raw.match(/\{[\s\S]*\}/);
-    if (match) {
-      const parsed = JSON.parse(match[0]) as Partial<ClarifiedSpec>;
-      const criteria =
-        Array.isArray(parsed.successCriteria) && parsed.successCriteria.length >= 1
-          ? parsed.successCriteria
-          : [`Address the topic: ${topic.slice(0, 100)}`];
-      // Hard floor of 3 — pad with the default if model returned fewer.
-      while (criteria.length < 3) {
-        criteria.push(`Open success criterion ${criteria.length + 1} (not specified by user)`);
-      }
-      return {
-        problemStatement: parsed.problemStatement ?? topic,
-        constraints: Array.isArray(parsed.constraints) ? parsed.constraints : [],
-        successCriteria: criteria,
-        scope: parsed.scope ?? "Determined by conversation context",
-        rawQA: [],
-      };
-    }
-  } catch {
-    // Fall through to original buildSpecFromTopic shape
-  }
-  return buildSpecFromTopic(topic, conversationContext);
-}
-
-async function* synthesizeSpec(
-  topic: string,
-  conversationContext: string,
-  qa: Array<{ id?: string; question: string; answer: string }>,
-  leaderModelId: string,
-  llm: CouncilLLM,
-  costAware = false,
-): AsyncGenerator<StreamChunk, ClarifiedSpec, unknown> {
-  if (qa.length === 0) {
-    // Clarifier asked 0 questions OR user skipped all of them. Use the LLM to
-    // pull implicit criteria/constraints/scope from the topic alone instead of
-    // returning the single-criterion fallback that makes leader-eval trivial.
-    return yield* inferSpecFromTopicOnly(topic, conversationContext, leaderModelId, llm, costAware);
-  }
-
-  const { system, prompt } = buildSpecSynthesisPrompt(topic, conversationContext, qa);
-  const resolved: Record<string, "answered" | "unspecified" | "skipped"> = {};
-  for (const item of qa) {
-    if (item.id) {
-      resolved[item.id] = "answered";
-    }
-  }
-
-  try {
-    const synthModel = pickCouncilTaskModel("spec_synthesis", leaderModelId, costAware);
-    const raw = yield* tracedGenerate(llm, {
-      phase: "synthesis",
-      label: "Synthesizing clarified spec",
-      modelId: synthModel,
-      system,
-      prompt,
-      maxTokens: 2048,
-    });
-    const match = raw.match(/\{[\s\S]*\}/);
-    if (match) {
-      const parsed = JSON.parse(match[0]) as Partial<ClarifiedSpec>;
-      return {
-        problemStatement: parsed.problemStatement ?? topic,
-        constraints: parsed.constraints ?? [],
-        successCriteria: parsed.successCriteria ?? [`Address: ${topic.slice(0, 100)}`],
-        scope: parsed.scope ?? "",
-        rawQA: qa,
-        resolved,
-      };
-    }
-  } catch {
-    // Fall through to default
-  }
-
-  return {
-    problemStatement: topic,
-    constraints: [],
-    successCriteria: [`Address: ${topic.slice(0, 100)}`],
-    scope: "",
-    rawQA: qa,
-    resolved,
-  };
-}