muonroi-cli 1.4.0 → 1.4.1

package/src/gsd/__tests__/types.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { detectGsdPhase, GSD_PHASES, isGsdPhase } from "../types";
-
-describe("GSD types", () => {
-  it("GSD_PHASES contains all expected phases", () => {
-    expect(GSD_PHASES).toContain("discuss");
-    expect(GSD_PHASES).toContain("plan");
-    expect(GSD_PHASES).toContain("execute");
-    expect(GSD_PHASES).toContain("verify");
-    expect(GSD_PHASES).toContain("review");
-    expect(GSD_PHASES).toContain("debug");
-    expect(GSD_PHASES.length).toBe(6);
-  });
-
-  it("isGsdPhase returns true for valid phases", () => {
-    expect(isGsdPhase("discuss")).toBe(true);
-    expect(isGsdPhase("plan")).toBe(true);
-    expect(isGsdPhase("execute")).toBe(true);
-    expect(isGsdPhase("verify")).toBe(true);
-    expect(isGsdPhase("review")).toBe(true);
-    expect(isGsdPhase("debug")).toBe(true);
-  });
-
-  it("detectGsdPhase routes fix/debug language to debug phase (session 127140a47b56)", () => {
-    // Position-based detection: when a debug keyword appears first, debug wins.
-    expect(detectGsdPhase("fix CI fail")).toBe("debug");
-    expect(detectGsdPhase("fix lỗi và check lại CI")).toBe("debug");
-    expect(detectGsdPhase("sửa bug này giúp tôi")).toBe("debug");
-    expect(detectGsdPhase("debug this crash")).toBe("debug");
-    // The exact session 127140a47b56 prompt — "fix" beats later "check".
-    expect(detectGsdPhase("action github đang run fail check và fix cho tôi")).toBe("debug");
-    // Without explicit debug keywords, "check" still falls through to verify.
-    expect(detectGsdPhase("check that this works")).toBe("verify");
-  });
-
-  it("isGsdPhase returns false for invalid strings", () => {
-    expect(isGsdPhase("unknown")).toBe(false);
-    expect(isGsdPhase("")).toBe(false);
-    expect(isGsdPhase("PLAN")).toBe(false);
-  });
-
-  it("detectGsdPhase detects plan from keywords", () => {
-    expect(detectGsdPhase("plan the implementation")).toBe("plan");
-    expect(detectGsdPhase("let's plan this feature")).toBe("plan");
-  });
-
-  it("detectGsdPhase detects execute from keywords", () => {
-    expect(detectGsdPhase("execute the plan now")).toBe("execute");
-    expect(detectGsdPhase("implement the feature")).toBe("execute");
-    expect(detectGsdPhase("build the component")).toBe("execute");
-  });
-
-  it("detectGsdPhase detects verify from keywords", () => {
-    expect(detectGsdPhase("verify the results")).toBe("verify");
-    expect(detectGsdPhase("validate that it works")).toBe("verify");
-    expect(detectGsdPhase("test the implementation")).toBe("verify");
-  });
-
-  it("detectGsdPhase detects review from keywords", () => {
-    expect(detectGsdPhase("review the code")).toBe("review");
-    expect(detectGsdPhase("audit the changes")).toBe("review");
-  });
-
-  it("detectGsdPhase detects discuss from keywords", () => {
-    expect(detectGsdPhase("discuss the approach")).toBe("discuss");
-    expect(detectGsdPhase("let's brainstorm ideas")).toBe("discuss");
-  });
-
-  it("detectGsdPhase returns null for no match", () => {
-    expect(detectGsdPhase("hello world")).toBeNull();
-    expect(detectGsdPhase("")).toBeNull();
-  });
-});
-
-describe("detectGsdPhase — ambiguity resolution", () => {
-  it("'implement the plan' returns execute (action verb wins)", () => {
-    expect(detectGsdPhase("implement the plan")).toBe("execute");
-  });
-
-  it("'plan the implementation' returns plan (plan appears first)", () => {
-    expect(detectGsdPhase("plan the implementation")).toBe("plan");
-  });
-
-  it("'discuss the plan before executing' returns discuss (discuss first)", () => {
-    expect(detectGsdPhase("discuss the plan before executing")).toBe("discuss");
-  });
-
-  it("'build and verify the feature' returns execute (build first)", () => {
-    expect(detectGsdPhase("build and verify the feature")).toBe("execute");
-  });
-});

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,141 +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[];
-  /**
-   * True when the prompt is informational/explanatory (a question or a
-   * self/meta analysis) rather than a request to change code. The deliverable
-   * is an ANSWER, not a diff — so the implement/verify flow is nonsensical and
-   * (live repro, session 829a83888dd2) leaks into the user-facing reply as a
-   * "2-3 line plan" preamble + process narration ("per contract 2/5/7", "emit
-   * respond_general"), agent-ifying an answer meant for a human. When set,
-   * buildDirective emits a human-facing question directive instead.
-   */
-  informational?: boolean;
-}
-
-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})` : "";
-  // Debug-phase variant: tighten exploration budget. Session 7d56a049e1e3
-  // ran 109 tool calls (58 bash + 33 read_file + 16 grep + 2 mcp) over 6
-  // minutes WITHOUT a single edit_file / write_file — agent over-researched
-  // the CI failure instead of attempting a fix. Add an explicit exploration
-  // cap and require committing to a hypothesis early.
-  if (input.phase === "debug") {
-    return [
-      `${HEADER} DEBUG task${phaseHint} — apply GSD-quick mindset, FIX-FIRST.`,
-      "Flow:",
-      "  1. State a 2-3 line hypothesis (what is failing, your best guess of why) BEFORE reading more than 3 files.",
-      "  2. Apply the smallest plausible fix with edit_file / write_file. Do NOT keep exploring — commit to a hypothesis, ship the diff, iterate on failure.",
-      "  3. Verify the fix (rerun the failing command / test) and report evidence.",
-      "Hard limits — exceed only if a tool result genuinely contradicts your hypothesis:",
-      "  - ≤ 8 read_file calls before first edit_file",
-      "  - ≤ 5 grep calls before first edit_file",
-      "  - ≤ 10 bash log-fetching calls (gh run view, cat log, etc.) before first edit_file",
-      "If hard limits are blown and you still have no fix, STOP and report what you tried + why you're stuck. Do NOT keep searching.",
-    ].join("\n");
-  }
-  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 buildQuestion(): string {
-  // Informational / question / meta-analysis turns. The deliverable is the
-  // answer itself — there is no code to implement or test. Keep the agent's
-  // process OUT of the reply: a human asked, a human reads the result.
-  return [
-    `${HEADER} QUESTION / explanatory request — no code change is being asked for.`,
-    "Answer it directly and completely, written for the HUMAN who asked:",
-    "  1. Investigate only as needed — read/grep the specific files that ground your answer this turn.",
-    "  2. Lead with the answer. Use clear prose + structure (headings, bullets). Where a claim rests on the code, cite a concise file:line inline.",
-    "  3. Do NOT output an implementation plan, do NOT narrate your own process or restate these instructions, and do NOT name internal layers / contract rules / tools as if the reader were the agent.",
-    "There is no implement/verify step — the answer is the deliverable.",
-  ].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 {
-  // Informational/meta prompts answer a human — never apply the
-  // implement/verify scaffold (it agent-ifies the reply), regardless of tier.
-  if (input.informational) {
-    return { text: buildQuestion(), tier: input.complexity.tier, blocking: false };
-  }
-  switch (input.complexity.tier) {
-    case "heavy":
-      return { text: buildHeavy(input), tier: "heavy", blocking: true };
-    case "standard":
-      return { text: buildStandard(input), tier: "standard", blocking: false };
-    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?.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,63 +0,0 @@
-export const GSD_PHASES = ["discuss", "plan", "execute", "verify", "review", "debug"] 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);
-}
-
-// PHASE_KEYWORDS notes (session 127140a47b56 root cause):
-// - "debug" is a phase that detection must prefer over "verify" / "execute"
-//   when bug/fail/error language is present. Without it, "fix CI fail check"
-//   matched "check" → verify, and the agent entered GSD-quick verify flow on
-//   what was actually a debug request.
-// - "fix" is now part of `debug` keywords (was missing); "build" stays in
-//   execute but loses precedence to debug fix-language.
-// - Vietnamese verbs added so multilingual prompts route correctly.
-const PHASE_KEYWORDS: Record<GsdPhase, string[]> = {
-  debug: ["debug", "fix", "bug", "broken", "fail", "failing", "error", "crash", "regression", "sửa", "lỗi", "hỏng"],
-  discuss: ["discuss", "brainstorm", "explore", "think about", "consider", "thảo luận"],
-  plan: ["plan", "design", "architect", "outline", "roadmap", "lập kế hoạch"],
-  execute: ["execute", "implement", "build", "create", "write", "code", "develop", "triển khai", "viết"],
-  verify: ["verify", "validate", "test", "check", "confirm", "ensure", "kiểm tra"],
-  review: ["review", "audit", "inspect", "examine", "evaluate", "đánh giá"],
-};
-
-// PHASE_PRIORITY notes:
-// - debug ranks ABOVE execute and verify. When a prompt contains both "fix"
-//   (debug) and "check" (verify), the debug intent should win — the user is
-//   asking us to fix something, the check is incidental.
-const PHASE_PRIORITY: Record<GsdPhase, number> = {
-  debug: 6,
-  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;
-}