muonroi-cli 1.6.5 → 1.7.0

package/dist/src/ui/modals/session-picker-modal.d.ts

@@ -0,0 +1,14 @@
+import type { SessionInfo } from "../../types/index.js";
+import type { Theme } from "../theme.js";
+/**
+ * Recent-sessions picker. Opened by `/sessions` or `/session`. Selecting a
+ * row relaunches the CLI with `--session <id>` (see ui/utils/relaunch.ts) so
+ * the user does not need to remember the id or restart by hand.
+ */
+export declare function SessionPickerModal({ t, sessions, focusIndex, width, height, }: {
+    t: Theme;
+    sessions: SessionInfo[];
+    focusIndex: number;
+    width: number;
+    height: number;
+}): import("react").ReactNode;

package/dist/src/ui/modals/session-picker-modal.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { bottomAlignedModalTop } from "../utils/modal.js";
+/**
+ * Recent-sessions picker. Opened by `/sessions` or `/session`. Selecting a
+ * row relaunches the CLI with `--session <id>` (see ui/utils/relaunch.ts) so
+ * the user does not need to remember the id or restart by hand.
+ */
+export function SessionPickerModal({ t, sessions, focusIndex, width, height, }) {
+    const panelWidth = Math.min(80, width - 6);
+    const rowCount = Math.max(sessions.length, 1);
+    // 4 chrome lines (title row + spacer + footer + paddings) + the rows
+    const contentHeight = rowCount + 4;
+    const maxH = Math.floor(height * 0.7);
+    const panelHeight = Math.min(contentHeight, maxH);
+    const top = bottomAlignedModalTop(height, panelHeight);
+    const overlayBg = "#000000cc";
+    return (_jsx("box", { position: "absolute", left: 0, top: 0, width: width, height: height, alignItems: "center", paddingTop: top, backgroundColor: overlayBg, children: _jsxs("box", { width: panelWidth, height: panelHeight, backgroundColor: t.backgroundPanel, paddingTop: 1, paddingBottom: 1, flexDirection: "column", children: [_jsxs("box", { flexShrink: 0, flexDirection: "row", justifyContent: "space-between", paddingLeft: 2, paddingRight: 2, children: [_jsx("text", { fg: t.primary, children: _jsx("b", { children: "Resume session" }) }), _jsx("text", { fg: t.textMuted, children: "esc" })] }), _jsx("scrollbox", { flexGrow: 1, minHeight: 0, children: sessions.length === 0 ? (_jsx("box", { paddingLeft: 2, paddingRight: 2, paddingTop: 1, children: _jsx("text", { fg: t.textMuted, children: "No prior sessions in this workspace." }) })) : (sessions.map((s, idx) => {
+                        const focused = idx === focusIndex;
+                        const ts = formatTimestamp(s.updatedAt);
+                        const titleRaw = s.title?.trim() || "(untitled)";
+                        const titleMax = Math.max(8, panelWidth - 38);
+                        const title = titleRaw.length > titleMax ? `${titleRaw.slice(0, titleMax - 1)}…` : titleRaw;
+                        const idShort = s.id.slice(-8);
+                        return (_jsxs("box", { backgroundColor: focused ? t.selectedBg : undefined, paddingLeft: 2, paddingRight: 2, width: "100%", flexDirection: "row", justifyContent: "space-between", children: [_jsx("text", { fg: focused ? t.selected : t.text, children: `${ts}  ${title}` }), _jsx("text", { fg: focused ? t.primary : t.textMuted, children: `${s.model}  ${idShort}` })] }, s.id));
+                    })) }), _jsx("box", { flexShrink: 0, paddingLeft: 2, paddingRight: 2, paddingTop: 1, children: _jsx("text", { fg: t.textMuted, children: "↑↓ navigate · enter resume (restarts CLI) · esc cancel" }) })] }) }));
+}
+/**
+ * Compact MM-DD HH:MM timestamp for the picker rows. Trades the year for
+ * space — the picker is workspace-scoped + lists the latest 20 sessions, so
+ * a year boundary is rare and an obvious context.
+ */
+function formatTimestamp(d) {
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    const hh = String(d.getHours()).padStart(2, "0");
+    const min = String(d.getMinutes()).padStart(2, "0");
+    return `${mm}-${dd} ${hh}:${min}`;
+}
+//# sourceMappingURL=session-picker-modal.js.map

package/dist/src/ui/utils/relaunch.d.ts

@@ -0,0 +1,41 @@
+/**
+ * src/ui/utils/relaunch.ts
+ *
+ * Helpers for "relaunch the CLI with a different session" — used by the
+ * /sessions picker so the user does not have to remember the id + restart
+ * the binary manually (the whole motivation of the picker).
+ *
+ * The argv mangling is a PURE function so it is unit-testable in isolation
+ * from the spawn side effects. `relaunchWithSession` glues argv mangling +
+ * child_process spawn + parent exit; it returns nothing (process replaces).
+ */
+import { spawn } from "node:child_process";
+/**
+ * Strip any existing `-s <id>` / `--session <id>` / `--session=<id>` from
+ * argv (kept indices intact otherwise) and append a fresh `--session <id>`.
+ * Pure — input arrays are not mutated.
+ *
+ * `argv` is in the shape Node provides: `[exec, scriptOrFirstArg, ...rest]`.
+ * The caller passes `process.argv.slice(1)` (the args part) and re-prepends
+ * `process.argv[0]` itself. We sanitize the WHOLE args portion in one pass.
+ */
+export declare function sanitizeArgvForResume(args: ReadonlyArray<string>, sessionId: string): string[];
+export interface RelaunchOptions {
+    /** Override process.argv (tests). Defaults to live process.argv. */
+    argv?: ReadonlyArray<string>;
+    /** Override the exit hook (tests). Defaults to process.exit. */
+    onExit?: (code: number) => void;
+    /** Injected spawn for tests. Defaults to the real node:child_process spawn. */
+    spawnFn?: typeof spawn;
+}
+/**
+ * Spawn a fresh CLI process bound to {sessionId} and exit the current one.
+ * Cross-platform: uses `stdio: "inherit"` so the child takes over the TTY,
+ * and `detached: false` so killing the parent's terminal kills the child
+ * (the user expects "close window = kill" semantics).
+ *
+ * NOTE: the caller should disconnect/teardown the current TUI before invoking
+ * this — the spawn happens immediately and the parent exit is on next tick,
+ * so any open file handles / MCP transports must be released first.
+ */
+export declare function relaunchWithSession(sessionId: string, opts?: RelaunchOptions): void;

package/dist/src/ui/utils/relaunch.js

@@ -0,0 +1,71 @@
+/**
+ * src/ui/utils/relaunch.ts
+ *
+ * Helpers for "relaunch the CLI with a different session" — used by the
+ * /sessions picker so the user does not have to remember the id + restart
+ * the binary manually (the whole motivation of the picker).
+ *
+ * The argv mangling is a PURE function so it is unit-testable in isolation
+ * from the spawn side effects. `relaunchWithSession` glues argv mangling +
+ * child_process spawn + parent exit; it returns nothing (process replaces).
+ */
+import { spawn } from "node:child_process";
+/**
+ * Strip any existing `-s <id>` / `--session <id>` / `--session=<id>` from
+ * argv (kept indices intact otherwise) and append a fresh `--session <id>`.
+ * Pure — input arrays are not mutated.
+ *
+ * `argv` is in the shape Node provides: `[exec, scriptOrFirstArg, ...rest]`.
+ * The caller passes `process.argv.slice(1)` (the args part) and re-prepends
+ * `process.argv[0]` itself. We sanitize the WHOLE args portion in one pass.
+ */
+export function sanitizeArgvForResume(args, sessionId) {
+    if (!sessionId || !sessionId.trim()) {
+        throw new Error("sanitizeArgvForResume: sessionId is required");
+    }
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "-s" || a === "--session") {
+            // skip the flag AND its value (if present and not another flag)
+            const next = args[i + 1];
+            if (next !== undefined && !next.startsWith("-"))
+                i++;
+            continue;
+        }
+        if (a.startsWith("--session=")) {
+            continue; // skip the combined form
+        }
+        out.push(a);
+    }
+    out.push("--session", sessionId);
+    return out;
+}
+/**
+ * Spawn a fresh CLI process bound to {sessionId} and exit the current one.
+ * Cross-platform: uses `stdio: "inherit"` so the child takes over the TTY,
+ * and `detached: false` so killing the parent's terminal kills the child
+ * (the user expects "close window = kill" semantics).
+ *
+ * NOTE: the caller should disconnect/teardown the current TUI before invoking
+ * this — the spawn happens immediately and the parent exit is on next tick,
+ * so any open file handles / MCP transports must be released first.
+ */
+export function relaunchWithSession(sessionId, opts = {}) {
+    const argv = opts.argv ?? process.argv;
+    const exec = argv[0];
+    if (!exec) {
+        throw new Error("relaunchWithSession: process.argv[0] is empty — cannot relaunch");
+    }
+    const exit = opts.onExit ?? ((code) => process.exit(code));
+    const spawnImpl = opts.spawnFn ?? spawn;
+    const args = sanitizeArgvForResume(argv.slice(1), sessionId);
+    const child = spawnImpl(exec, args, { stdio: "inherit", detached: false });
+    child.once("error", (err) => {
+        console.error(`[relaunch] spawn failed: ${err?.message ?? err}`);
+        exit(1);
+    });
+    // Hand the TTY to the child and exit cleanly. The child takes over rendering.
+    child.once("spawn", () => exit(0));
+}
+//# sourceMappingURL=relaunch.js.map

package/dist/src/ui/utils/relaunch.test.js

@@ -0,0 +1,83 @@
+import { EventEmitter } from "node:events";
+import { describe, expect, it, vi } from "vitest";
+import { relaunchWithSession, sanitizeArgvForResume } from "./relaunch.js";
+describe("sanitizeArgvForResume", () => {
+    it("appends --session when no prior session flag exists", () => {
+        expect(sanitizeArgvForResume(["-m", "grok-build-0.1"], "abc-123")).toEqual([
+            "-m",
+            "grok-build-0.1",
+            "--session",
+            "abc-123",
+        ]);
+    });
+    it("strips an existing `-s <id>` and replaces it", () => {
+        expect(sanitizeArgvForResume(["-s", "old-id", "-m", "grok-build-0.1"], "new-id")).toEqual([
+            "-m",
+            "grok-build-0.1",
+            "--session",
+            "new-id",
+        ]);
+    });
+    it("strips an existing `--session <id>` (long form)", () => {
+        expect(sanitizeArgvForResume(["--session", "old-id", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
+    });
+    it("strips the combined `--session=<id>` form", () => {
+        expect(sanitizeArgvForResume(["--session=old-id", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
+    });
+    it("strips `--session` even when its value looks like another flag (treats value as missing)", () => {
+        // edge: user typed `--session --batch-api` — we don't eat the next flag
+        expect(sanitizeArgvForResume(["--session", "--batch-api", "-y"], "new-id")).toEqual([
+            "--batch-api",
+            "-y",
+            "--session",
+            "new-id",
+        ]);
+    });
+    it("removes multiple stray session flags (defensive — last wins)", () => {
+        expect(sanitizeArgvForResume(["-s", "a", "--session", "b", "--session=c"], "z")).toEqual(["--session", "z"]);
+    });
+    it("throws when sessionId is empty or whitespace", () => {
+        expect(() => sanitizeArgvForResume([], "")).toThrow(/sessionId is required/);
+        expect(() => sanitizeArgvForResume([], "  ")).toThrow(/sessionId is required/);
+    });
+});
+describe("relaunchWithSession", () => {
+    it("spawns the same executable with the sanitized argv + session id, then exits 0", () => {
+        const exitMock = vi.fn();
+        const child = new EventEmitter();
+        const spawnMock = vi.fn(() => child);
+        relaunchWithSession("sess-xyz", {
+            argv: ["/usr/local/bin/muonroi-cli", "-m", "grok-build-0.1"],
+            onExit: exitMock,
+            spawnFn: spawnMock,
+        });
+        expect(spawnMock).toHaveBeenCalledTimes(1);
+        expect(spawnMock).toHaveBeenCalledWith("/usr/local/bin/muonroi-cli", ["-m", "grok-build-0.1", "--session", "sess-xyz"], { stdio: "inherit", detached: false });
+        // exit fires on the child's "spawn" event
+        child.emit("spawn");
+        expect(exitMock).toHaveBeenCalledWith(0);
+    });
+    it("exits 1 if the child spawn errors before starting", () => {
+        const exitMock = vi.fn();
+        const errMock = vi.spyOn(console, "error").mockImplementation(() => { });
+        const child = new EventEmitter();
+        const spawnMock = vi.fn(() => child);
+        relaunchWithSession("sess-xyz", {
+            argv: ["/bin/muonroi", "-y"],
+            onExit: exitMock,
+            spawnFn: spawnMock,
+        });
+        child.emit("error", new Error("ENOENT"));
+        expect(exitMock).toHaveBeenCalledWith(1);
+        expect(errMock).toHaveBeenCalled();
+        errMock.mockRestore();
+    });
+    it("throws when argv[0] is missing (cannot relaunch without an executable)", () => {
+        expect(() => relaunchWithSession("sess", {
+            argv: [],
+            onExit: () => { },
+            spawnFn: (() => new EventEmitter()),
+        })).toThrow(/process\.argv\[0\] is empty/);
+    });
+});
+//# sourceMappingURL=relaunch.test.js.map

package/package.json

@@ -3,7 +3,7 @@
   "workspaces": [
     "packages/*"
   ],
-  "version": "1.6.5",
+  "version": "1.7.0",
   "description": "BYOK AI coding agent with multi-model council debate, role-based routing, and auto-compact.",
   "repository": {
     "type": "git",

package/dist/src/gsd/complexity.d.ts

@@ -1,28 +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[];
-}
-export declare function scoreComplexity(prompt: string): ComplexityResult;

package/dist/src/gsd/complexity.js

@@ -1,103 +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.
- */
-/** Patterns that strongly suggest a large, multi-step undertaking. */
-const HEAVY_PATTERNS = [
-    { 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 = [
-    { 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) {
-    const signals = [];
-    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;
-    if (score >= HEAVY_THRESHOLD)
-        tier = "heavy";
-    else if (score <= QUICK_THRESHOLD)
-        tier = "quick";
-    else
-        tier = "standard";
-    return { tier, score, signals };
-}
-//# sourceMappingURL=complexity.js.map

package/dist/src/gsd/directives.js

@@ -1,154 +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.
- */
-const HEADER = "[gsd-native]";
-/**
- * High-precision predicate: is this turn about the Muonroi ECOSYSTEM (where the
- * muonroi-docs MCP is the right source), as opposed to muonroi-cli internals?
- * Deliberately TIGHTER than smart-filter's hasEcosystemSignal — that one keeps
- * the server (over-keeping costs only tokens), but a behavioural "call docs
- * FIRST" nudge must not fire on every "muonroi" mention or it misdirects
- * CLI-internals questions toward .NET package docs. EN + VI.
- */
-const ECOSYSTEM_SCOPE_RE = /\becosystem\b|hệ\s*sinh\s*thái|he\s*sinh\s*thai|building[-\s]?block|open[-\s]?core|rule\s*engine|decision\s*table|\bnuget\b/i;
-export function mentionsEcosystemScope(message) {
-    return ECOSYSTEM_SCOPE_RE.test(message);
-}
-/**
- * Appended to any directive when the turn is ecosystem-scoped. Phrased
- * conditionally ("if … available") so it is harmless when muonroi-docs is not
- * configured — the model simply finds no such tool and falls back to local files.
- */
-export const ECOSYSTEM_DOCS_NUDGE = [
-    `${HEADER} ECOSYSTEM SCOPE — this turn concerns the Muonroi ecosystem (platform overview, BB/.NET packages, building-block, open-core boundary, setup).`,
-    "If the muonroi-docs MCP is available, it is the AUTHORITATIVE source — call it FIRST (docs_search / setup_guide / bb_recipe_list / bb_package_describe), THEN ground with local files. Do NOT characterize the ecosystem from local repo files alone.",
-].join("\n");
-/**
- * Appended to any directive when the user's reply language is non-English.
- * The base system prompt's "reply in user's language" rule normally suffices,
- * but `concise` / `FIX-FIRST` / GSD-debug directive bodies stack on top of it
- * with strong "be terse / code over prose" language that crowds the rule out
- * — observed live (storyflow_ui 22661c8de9f2). This NUDGE re-anchors the rule
- * inside the directive itself so brevity preferences cannot override it.
- */
-export function buildLanguageNudge(lang) {
-    return [
-        `${HEADER} LANGUAGE — the user wrote in ${lang}. Reply in ${lang}.`,
-        "This rule OVERRIDES any brevity / concise / code-over-prose directive: terseness is fine, but the response language stays the user's.",
-    ].join("\n");
-}
-function renderGrayAreas(qs) {
-    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) {
-    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) {
-    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() {
-    // 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) {
-    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) {
-    // Informational/meta prompts answer a human — never apply the
-    // implement/verify scaffold (it agent-ifies the reply), regardless of tier.
-    const base = input.informational
-        ? { text: buildQuestion(), tier: input.complexity.tier, blocking: false }
-        : input.complexity.tier === "heavy"
-            ? { text: buildHeavy(input), tier: "heavy", blocking: true }
-            : input.complexity.tier === "standard"
-                ? { text: buildStandard(input), tier: "standard", blocking: false }
-                : { text: buildQuick(input), tier: "quick", blocking: false };
-    // Ecosystem-scoped turns get a docs-first nudge regardless of tier (question
-    // OR task): muonroi-docs is the authoritative source and must not be skipped
-    // in favour of guessing from local files (session 41ccfeb2ceee turn 1).
-    let text = base.text;
-    if (input.ecosystem) {
-        text = `${text}\n${ECOSYSTEM_DOCS_NUDGE}`;
-    }
-    // Language nudge: re-anchor the "reply in user's language" rule INSIDE the
-    // directive when the user wrote in a non-English language, so layered
-    // brevity/concise directives can't drown it (storyflow_ui 22661c8de9f2).
-    if (input.replyLanguage) {
-        text = `${text}\n${buildLanguageNudge(input.replyLanguage)}`;
-    }
-    return { ...base, text };
-}
-//# sourceMappingURL=directives.js.map