muonroi-cli 1.3.4 → 1.4.1

package/dist/src/pil/pipeline.js

@@ -18,20 +18,25 @@ import { getCachedEEClientMode } from "../ee/client-mode.js";
 import { classifyEeError, logEeFailure } from "../utils/ee-logger.js";
 import { DEFAULT_TOKEN_BUDGET } from "./budget.js";
 import { appendPilLog } from "./budget-log.js";
+import { isDiscoveryEnabled } from "./config.js";
+import { scoreComplexitySize } from "./layer1_5-complexity-size.js";
 import { layer1Intent } from "./layer1-intent.js";
 import { layer2Personality } from "./layer2-personality.js";
 import { layer3EeInjection } from "./layer3-ee-injection.js";
 import { layer4Gsd } from "./layer4-gsd.js";
 import { layer5Context } from "./layer5-context.js";
-import { layer6Output } from "./layer6-output.js";
+import { isMetaAnalysisPrompt, layer6Output } from "./layer6-output.js";
 import { PipelineContextSchema } from "./schema.js";
+import { bumpSessionTurn } from "./session-state.js";
 import { setPilLastResult } from "./store.js";
 import { resolveAfter } from "./timeout.js";
-const PIPELINE_TIMEOUT_FAST_MS = 200;
+const PIPELINE_TIMEOUT_FAST_MS = 1500;
 // Sized from measured /api/pil-context distribution after server-side
 // classify+embed parallelization (commit 5b77bab in experience-engine).
 // 120-call sample: p50=1155ms, p95=2171ms, p99=2734ms, max=3105ms. 3500ms
-// gives ~800ms margin over p99. Drop further only after another infra win.
+// gives ~800ms margin over p99. Raised FAST from 200→1500 for agent comfort
+// on turns where no EE serverBaseUrl is configured (brain path already uses 3500
+// via getCachedServerBaseUrl() or getCachedEEClientMode()).
 const PIPELINE_TIMEOUT_BRAIN_MS = 3500;
 function pipelineTimeoutMs() {
     // Allow test environments to override the timeout to avoid flaky races when
@@ -39,7 +44,7 @@ function pipelineTimeoutMs() {
     const envOverride = process.env.MUONROI_TEST_PIPELINE_TIMEOUT_MS;
     if (envOverride) {
         const parsed = parseInt(envOverride, 10);
-        if (!isNaN(parsed) && parsed > 0)
+        if (!Number.isNaN(parsed) && parsed > 0)
             return parsed;
     }
     const mode = getCachedEEClientMode();
@@ -64,7 +69,7 @@ const SKIPPED_LAYERS = [
     { timingName: "layer4-gsd-structuring", deltaName: "gsd-workflow-structuring" },
     { timingName: "layer5-context-enrichment", deltaName: "context-enrichment" },
 ];
-async function runLayers(ctx) {
+async function runLayers(ctx, options) {
     const pipelineStart = Date.now();
     const timings = [];
     // Track each layer's contribution to the enriched-prompt size so the
@@ -79,12 +84,76 @@ async function runLayers(ctx) {
         timings.push({ name, ms });
         layerSnapshots.push({ name, charsBefore, charsAfter, charsDelta: charsAfter - charsBefore, durationMs: ms });
     }
-    await timed("layer1-intent", layer1Intent);
+    await timed("layer1-intent", (c) => layer1Intent(c, { llmFallback: options?.llmFallback }));
+    // Layer 1.5: deterministic complexity-size classification. Pure heuristic,
+    // no LLM call, no network. Consumed by 4B (step ceiling matrix) and 4A
+    // (scope-reminder cadence K). Mirrored into _intentTrace for forensics.
+    {
+        const sizeResult = scoreComplexitySize({
+            rawText: ctx.raw,
+            taskType: ctx.taskType ?? "general",
+        });
+        ctx = {
+            ...ctx,
+            complexitySize: sizeResult,
+            _intentTrace: ctx._intentTrace
+                ? {
+                    ...ctx._intentTrace,
+                    complexitySize: sizeResult.size,
+                    complexitySizeScore: sizeResult.score,
+                }
+                : ctx._intentTrace,
+        };
+    }
+    // Phase 1 discovery: L1.5–L1.8 (interactive, no hard timeout)
+    if (isDiscoveryEnabled() && ctx.intentKind !== "chitchat") {
+        const { runDiscovery } = await import("./discovery.js");
+        const discoveryStart = Date.now();
+        try {
+            const l1Result = {
+                taskType: ctx.taskType,
+                confidence: ctx.confidence,
+                complexity: (ctx._intentTrace?.complexity ?? "low"),
+                domain: ctx.domain,
+                outputStyle: ctx.outputStyle,
+                intentKind: ctx.intentKind ?? null,
+            };
+            const discovery = await runDiscovery(ctx.raw, l1Result, process.cwd(), options?.interactionHandler ?? null, ctx.sessionId ?? null, options?.clarificationProposer ?? null, options?.recentTurnsSummary ?? null);
+            ctx = { ...ctx, _discoveryResult: discovery };
+            if (discovery.interviewed && discovery.accepted) {
+                const discoveryPrefix = [
+                    `[Discovery] Intent: ${discovery.intentStatement}`,
+                    `[Discovery] Outcome: ${discovery.outcome}`,
+                    discovery.scope.length > 0 ? `[Discovery] Scope: ${discovery.scope.join(", ")}` : "",
+                    discovery.feasibilityWarnings.length > 0
+                        ? `[Discovery] Warnings: ${discovery.feasibilityWarnings.join("; ")}`
+                        : "",
+                ]
+                    .filter(Boolean)
+                    .join("\n");
+                ctx = { ...ctx, enriched: `${discoveryPrefix}\n\n${ctx.enriched}` };
+            }
+            if (!discovery.accepted) {
+                return { ...ctx, enriched: ctx.raw, fallbackReason: "discovery-cancelled" };
+            }
+        }
+        catch (err) {
+            console.error("[Agent:discovery] runDiscovery failed — continuing with L1 result only", err);
+        }
+        timings.push({ name: "discovery", ms: Date.now() - discoveryStart });
+    }
     if (ctx.taskType !== null) {
         await timed("layer2-personality", layer2Personality);
-        await timed("layer3-ee-injection", layer3EeInjection);
-        await timed("layer4-gsd-structuring", layer4Gsd);
-        await timed("layer5-context-enrichment", layer5Context);
+        if (isMetaAnalysisPrompt(ctx.raw)) {
+            // FIX: skip heavy EE (layer3) + context (layer5) for meta-analysis turns
+            // to reduce PIL overhead on evaluation/improvement questions (as intended).
+            await timed("layer4-gsd-structuring", layer4Gsd);
+        }
+        else {
+            await timed("layer3-ee-injection", layer3EeInjection);
+            await timed("layer4-gsd-structuring", layer4Gsd);
+            await timed("layer5-context-enrichment", layer5Context);
+        }
     }
     else {
         for (const { timingName } of SKIPPED_LAYERS) {
@@ -139,6 +208,10 @@ async function runLayers(ctx) {
     return ctx;
 }
 export async function runPipeline(raw, options) {
+    // Bump the per-session turn counter BEFORE any pipeline work so discovery
+    // can distinguish first-turn (full interview) from follow-ups (skip).
+    // Safe to call with null sessionId — bumpSessionTurn no-ops in that case.
+    bumpSessionTurn(options?.sessionId ?? null);
     const fallback = {
         raw,
         enriched: raw,
@@ -156,10 +229,13 @@ export async function runPipeline(raw, options) {
         fallbackReason: null,
     };
     try {
-        const result = await Promise.race([
-            runLayers({ ...fallback }),
-            resolveAfter(pipelineTimeoutMs(), { ...fallback, fallbackReason: "pipeline-timeout" }),
-        ]);
+        const hasInteractiveDiscovery = !!options?.interactionHandler && isDiscoveryEnabled();
+        const result = hasInteractiveDiscovery
+            ? await runLayers({ ...fallback }, options)
+            : await Promise.race([
+                runLayers({ ...fallback }, options),
+                resolveAfter(pipelineTimeoutMs(), { ...fallback, fallbackReason: "pipeline-timeout" }),
+            ]);
         const parse = PipelineContextSchema.safeParse(result);
         if (!parse.success) {
             const validated = {

package/dist/src/pil/response-tools.d.ts

@@ -59,5 +59,61 @@ declare const GeneralSchema: z.ZodObject<{
 export declare const RESPONSE_TOOL_PREFIX = "respond_";
 export declare function isResponseTool(toolName: string): boolean;
 export declare function getResponseTaskType(toolName: string): string | null;
+/**
+ * True when an AI-SDK step emitted at least one response tool (`respond_*`).
+ *
+ * A response tool is the model's FINAL structured answer and is terminal by
+ * construction — its `execute` is identity (`input => input`), so the payload
+ * lives entirely in the tool-call arguments.
+ *
+ * Loose step shape: the AI-SDK step type is generic over the toolset; we only
+ * need each step's `toolCalls[].toolName`.
+ */
+export declare function stepEmittedResponseTool(step: {
+    toolCalls?: ReadonlyArray<{
+        toolName?: string;
+    }>;
+} | undefined): boolean;
+/**
+ * Number of *blind* (no prior investigation) response-tool steps tolerated
+ * before the loop is force-halted. One blind response is allowed as a grace
+ * for the "announce intent, then go investigate" pattern (session
+ * e4a9d97a90); a second blind response with zero real tool work is a
+ * narration loop and is halted.
+ */
+export declare const BLIND_RESPONSE_STEP_LIMIT = 2;
+/**
+ * Decide whether a response-tool emission should TERMINATE the streamText loop.
+ *
+ * A `respond_*` tool is the model's FINAL structured answer, so emitting one is
+ * normally terminal. But cheap models (grok-build-0.1) sometimes emit it
+ * PREMATURELY — announcing intent ("I need to inspect the code first") before
+ * doing any investigation. Session e4a9d97a90: a single blind `respond_general`
+ * at step 0 with zero reads; halting on the FIRST response tool unconditionally
+ * (the original d95113d3 loop fix) stopped the turn and the agent never read the
+ * code the user asked about ("dừng ở respond_general không làm gì tiếp").
+ *
+ * Discriminator — purely structural, no NLP:
+ *  - REAL WORK DONE: if any earlier (or same) step in the turn called a
+ *    non-response tool (read_file/grep/bash/...), the response tool is the
+ *    model's CONSIDERED answer → terminal. This is the common, well-behaved
+ *    path and the one d95113d3 seq=27 hit (7 grep/read calls, THEN 87×
+ *    respond_general): halting on the first post-investigation response kills
+ *    the loop at call #1 and costs no extra LLM round-trip.
+ *  - BLIND: a response tool with no prior real work means the model answered
+ *    without investigating. Allow ONE such response (grace for announce →
+ *    investigate), but halt once a SECOND blind response step occurs
+ *    (`>= BLIND_RESPONSE_STEP_LIMIT`) with still no real work — that is a pure
+ *    narration loop (session 9b1b3: 2× blind respond_general).
+ *
+ * The orthogonal case of many response tools crammed into ONE generation
+ * (session 8d8f498268ed: 80×) is bounded separately by the in-stream
+ * RESPONSE_TOOL_SPAM_CAP in the orchestrator — stopWhen only runs BETWEEN steps.
+ */
+export declare function shouldHaltOnResponseTool(steps: ReadonlyArray<{
+    toolCalls?: ReadonlyArray<{
+        toolName?: string;
+    }>;
+}> | undefined): boolean;
 export declare function buildResponseTools(taskType: string): ToolSet;
 export { AnalyzeSchema, DebugSchema, DocsSchema, GeneralSchema, GenerateSchema, PlanSchema, RefactorSchema };

package/dist/src/pil/response-tools.js

@@ -50,8 +50,10 @@ const GenerateSchema = z.object({
     explanation: z.string().optional().describe("Brief design rationale"),
 });
 const GeneralSchema = z.object({
-    response: z.string().describe("Direct answer to the user"),
-    reasoning: z.string().optional().describe("Optional brief reasoning"),
+    response: z
+        .string()
+        .describe("Complete, full-length answer. Use rich markdown formatting (headings, bullet points, bold text, code blocks) to structure the information clearly. Avoid dense walls of text or long unformatted paragraphs. Ensure the output is highly readable and scannable for a developer. For analysis or meta questions, include all findings and evidence citations (file:line). Truncation defeats the purpose."),
+    reasoning: z.string().optional().describe("Optional brief internal reasoning (not shown as primary answer)"),
 });
 const RESPONSE_SCHEMAS = {
     refactor: RefactorSchema,
@@ -70,6 +72,78 @@ export function getResponseTaskType(toolName) {
     const suffix = toolName.slice(RESPONSE_TOOL_PREFIX.length);
     return suffix in RESPONSE_SCHEMAS ? suffix : null;
 }
+/**
+ * True when an AI-SDK step emitted at least one response tool (`respond_*`).
+ *
+ * A response tool is the model's FINAL structured answer and is terminal by
+ * construction — its `execute` is identity (`input => input`), so the payload
+ * lives entirely in the tool-call arguments.
+ *
+ * Loose step shape: the AI-SDK step type is generic over the toolset; we only
+ * need each step's `toolCalls[].toolName`.
+ */
+export function stepEmittedResponseTool(step) {
+    return Boolean(step?.toolCalls?.some((c) => Boolean(c?.toolName) && isResponseTool(c.toolName)));
+}
+/**
+ * Number of *blind* (no prior investigation) response-tool steps tolerated
+ * before the loop is force-halted. One blind response is allowed as a grace
+ * for the "announce intent, then go investigate" pattern (session
+ * e4a9d97a90); a second blind response with zero real tool work is a
+ * narration loop and is halted.
+ */
+export const BLIND_RESPONSE_STEP_LIMIT = 2;
+/**
+ * Decide whether a response-tool emission should TERMINATE the streamText loop.
+ *
+ * A `respond_*` tool is the model's FINAL structured answer, so emitting one is
+ * normally terminal. But cheap models (grok-build-0.1) sometimes emit it
+ * PREMATURELY — announcing intent ("I need to inspect the code first") before
+ * doing any investigation. Session e4a9d97a90: a single blind `respond_general`
+ * at step 0 with zero reads; halting on the FIRST response tool unconditionally
+ * (the original d95113d3 loop fix) stopped the turn and the agent never read the
+ * code the user asked about ("dừng ở respond_general không làm gì tiếp").
+ *
+ * Discriminator — purely structural, no NLP:
+ *  - REAL WORK DONE: if any earlier (or same) step in the turn called a
+ *    non-response tool (read_file/grep/bash/...), the response tool is the
+ *    model's CONSIDERED answer → terminal. This is the common, well-behaved
+ *    path and the one d95113d3 seq=27 hit (7 grep/read calls, THEN 87×
+ *    respond_general): halting on the first post-investigation response kills
+ *    the loop at call #1 and costs no extra LLM round-trip.
+ *  - BLIND: a response tool with no prior real work means the model answered
+ *    without investigating. Allow ONE such response (grace for announce →
+ *    investigate), but halt once a SECOND blind response step occurs
+ *    (`>= BLIND_RESPONSE_STEP_LIMIT`) with still no real work — that is a pure
+ *    narration loop (session 9b1b3: 2× blind respond_general).
+ *
+ * The orthogonal case of many response tools crammed into ONE generation
+ * (session 8d8f498268ed: 80×) is bounded separately by the in-stream
+ * RESPONSE_TOOL_SPAM_CAP in the orchestrator — stopWhen only runs BETWEEN steps.
+ */
+export function shouldHaltOnResponseTool(steps) {
+    if (!steps || steps.length === 0)
+        return false;
+    if (!stepEmittedResponseTool(steps[steps.length - 1]))
+        return false;
+    let responseSteps = 0;
+    let didRealWork = false;
+    for (const s of steps) {
+        let stepHasResponse = false;
+        for (const c of s?.toolCalls ?? []) {
+            const name = c?.toolName;
+            if (!name)
+                continue;
+            if (isResponseTool(name))
+                stepHasResponse = true;
+            else
+                didRealWork = true;
+        }
+        if (stepHasResponse)
+            responseSteps += 1;
+    }
+    return didRealWork || responseSteps >= BLIND_RESPONSE_STEP_LIMIT;
+}
 export function buildResponseTools(taskType) {
     const schema = RESPONSE_SCHEMAS[taskType];
     if (!schema)

package/dist/src/pil/schema.d.ts

@@ -85,11 +85,20 @@ export declare const PipelineContextSchema: z.ZodObject<{
         standard: "standard";
         heavy: "heavy";
     }>>>;
+    complexitySize: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        size: z.ZodEnum<{
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>;
+        score: z.ZodNumber;
+        features: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>>;
     grayAreas: z.ZodOptional<z.ZodArray<z.ZodObject<{
         dimension: z.ZodEnum<{
+            format: "format";
             scope: "scope";
             target: "target";
-            format: "format";
             convention: "convention";
             depth: "depth";
             audience: "audience";

package/dist/src/pil/schema.js

@@ -41,6 +41,14 @@ export const PipelineContextSchema = z.object({
     digestAgeMs: z.number().nullable().optional(),
     sessionId: z.string().nullable().optional(),
     complexityTier: z.enum(["quick", "standard", "heavy"]).nullable().optional(),
+    complexitySize: z
+        .object({
+        size: z.enum(["small", "medium", "large"]),
+        score: z.number(),
+        features: z.record(z.string(), z.union([z.number(), z.boolean()])),
+    })
+        .nullable()
+        .optional(),
     grayAreas: z
         .array(z.object({
         dimension: z.enum(["scope", "target", "format", "convention", "depth", "audience"]),

package/dist/src/pil/session-state.d.ts

@@ -0,0 +1,44 @@
+/**
+ * src/pil/session-state.ts
+ *
+ * Per-session turn counter and discovery memo. PIL discovery (Layer 1.6
+ * Clarity Interview + Layer 1.8 Acceptance) was originally stateless across
+ * turns — every user prompt re-ran gap detection from scratch, with no
+ * awareness that the user had already had N exchanges in the same session.
+ *
+ * Evidence (session 1f29e238a816): user typed "Can you fix it?" as a
+ * follow-up after a completed CI-fix task. PIL classified the short
+ * pronoun-prompt as taskType=debug, detected a scope gap ("no file
+ * referenced"), and fired an interview askcard. When the user re-typed
+ * their intent as freetext to the askcard, PIL treated it as a gap answer
+ * rather than a fresh prompt, looping through accept/adjust → another
+ * interview askcard.
+ *
+ * Root cause: PIL pipeline has no input that says "this is the Nth turn
+ * of an ongoing conversation". This module supplies that signal. The
+ * discovery layer can use it to short-circuit interview/acceptance on
+ * continuation-style prompts.
+ *
+ * State lives on `globalThis.__muonroiPilSessionState` so it survives
+ * across `runPipeline` calls within the same CLI process. There is no
+ * persistence — restarting the CLI resets all session state, which
+ * matches user mental model (a new session begins discovery from scratch).
+ */
+export interface PilSessionState {
+    /** Number of user prompts seen in this session so far (incremented per pipeline run). */
+    turnCount: number;
+    /** Timestamp of the most-recent accepted discovery; null if no discovery has been accepted yet. */
+    lastAcceptedDiscoveryAt: number | null;
+}
+export declare function getSessionState(sessionId: string | null | undefined): PilSessionState | null;
+/**
+ * Bump the turn counter for `sessionId`. Called once per `runPipeline`
+ * invocation. The post-increment count is returned so the caller can act
+ * on "first turn" (count===1) vs "follow-up" (count>1) without a second
+ * lookup.
+ */
+export declare function bumpSessionTurn(sessionId: string | null | undefined): number;
+export declare function markDiscoveryAccepted(sessionId: string | null | undefined, at?: number): void;
+/** Test helper — clear all session state. Not exported for production use. */
+export declare function _resetForTests(): void;
+export declare function isLikelyFollowUp(raw: string): boolean;

package/dist/src/pil/session-state.js

@@ -0,0 +1,143 @@
+/**
+ * src/pil/session-state.ts
+ *
+ * Per-session turn counter and discovery memo. PIL discovery (Layer 1.6
+ * Clarity Interview + Layer 1.8 Acceptance) was originally stateless across
+ * turns — every user prompt re-ran gap detection from scratch, with no
+ * awareness that the user had already had N exchanges in the same session.
+ *
+ * Evidence (session 1f29e238a816): user typed "Can you fix it?" as a
+ * follow-up after a completed CI-fix task. PIL classified the short
+ * pronoun-prompt as taskType=debug, detected a scope gap ("no file
+ * referenced"), and fired an interview askcard. When the user re-typed
+ * their intent as freetext to the askcard, PIL treated it as a gap answer
+ * rather than a fresh prompt, looping through accept/adjust → another
+ * interview askcard.
+ *
+ * Root cause: PIL pipeline has no input that says "this is the Nth turn
+ * of an ongoing conversation". This module supplies that signal. The
+ * discovery layer can use it to short-circuit interview/acceptance on
+ * continuation-style prompts.
+ *
+ * State lives on `globalThis.__muonroiPilSessionState` so it survives
+ * across `runPipeline` calls within the same CLI process. There is no
+ * persistence — restarting the CLI resets all session state, which
+ * matches user mental model (a new session begins discovery from scratch).
+ */
+function getMap() {
+    const g = globalThis;
+    let map = g.__muonroiPilSessionState;
+    if (!(map instanceof Map)) {
+        map = new Map();
+        g.__muonroiPilSessionState = map;
+    }
+    return map;
+}
+export function getSessionState(sessionId) {
+    if (!sessionId)
+        return null;
+    return getMap().get(sessionId) ?? null;
+}
+/**
+ * Bump the turn counter for `sessionId`. Called once per `runPipeline`
+ * invocation. The post-increment count is returned so the caller can act
+ * on "first turn" (count===1) vs "follow-up" (count>1) without a second
+ * lookup.
+ */
+export function bumpSessionTurn(sessionId) {
+    if (!sessionId)
+        return 1;
+    const map = getMap();
+    const prior = map.get(sessionId);
+    const next = {
+        turnCount: (prior?.turnCount ?? 0) + 1,
+        lastAcceptedDiscoveryAt: prior?.lastAcceptedDiscoveryAt ?? null,
+    };
+    map.set(sessionId, next);
+    return next.turnCount;
+}
+export function markDiscoveryAccepted(sessionId, at = Date.now()) {
+    if (!sessionId)
+        return;
+    const map = getMap();
+    const prior = map.get(sessionId);
+    map.set(sessionId, {
+        turnCount: prior?.turnCount ?? 1,
+        lastAcceptedDiscoveryAt: at,
+    });
+}
+/** Test helper — clear all session state. Not exported for production use. */
+export function _resetForTests() {
+    globalThis.__muonroiPilSessionState = undefined;
+}
+/**
+ * Heuristic: is `raw` likely a continuation of a prior turn rather than a
+ * fresh task description?
+ *
+ * Hits when the prompt is short AND either:
+ *   - starts with a request modal that refers to prior context ("can you",
+ *     "could you", "please", "now", "also", "what about", "try", "again",
+ *     "redo", "do it", "fix it", "tiếp", "làm tiếp", "vậy thì")
+ *   - contains a context pronoun ("it", "this", "that", "those", "them",
+ *     "nó", "cái đó", "cái này") without any concrete noun anchor
+ *
+ * Does NOT match long detailed prompts even if they start with "can you"
+ * (those genuinely describe a new task). The 80-char cap is empirically
+ * tuned: real follow-ups in chat-export samples were 8-50 chars; new
+ * task prompts averaged >100 chars.
+ */
+// ASCII-only prefix patterns. Vietnamese phrases are matched separately via
+// lowercase substring checks because the JS `\b` boundary is ASCII-aware and
+// fires inside multi-byte characters, breaking simple "starts with this
+// phrase" intent. Splitting the two paths keeps each predicate simple and
+// easy to reason about in unit tests.
+const FOLLOW_UP_PREFIX_RE = /^\s*(can|could|would|will)\s+you\b|^\s*please\b|^\s*(now|also|then|next)\b|^\s*(what|how)\s+about\b|^\s*(try|redo|again|do|fix)\b/i;
+// ASCII pronoun anchors. Order matters — checked alongside char-length cap.
+const CONTEXT_PRONOUN_RE = /\b(it|this|that|those|them)\b/i;
+// Vietnamese prefix phrases. Compared via lowercased startsWith so diacritics
+// match exactly without relying on \b.
+const VI_PREFIX_PHRASES = [
+    "tiếp",
+    "tiep",
+    "làm tiếp",
+    "lam tiep",
+    "vậy thì",
+    "vay thi",
+    "thế thì",
+    "the thi",
+    "vậy bạn",
+    "vay ban",
+    "vậy hãy",
+    "vay hay",
+    "nó ",
+    "no ",
+    "cái đó",
+    "cai do",
+    "cái này",
+    "cai nay",
+    "và ",
+    "va ",
+];
+const MAX_FOLLOWUP_CHARS = 80;
+export function isLikelyFollowUp(raw) {
+    const t = (raw ?? "").trim();
+    if (!t || t.length > MAX_FOLLOWUP_CHARS)
+        return false;
+    if (FOLLOW_UP_PREFIX_RE.test(t))
+        return true;
+    const lower = t.toLowerCase();
+    for (const phrase of VI_PREFIX_PHRASES) {
+        if (lower === phrase.trim() || lower.startsWith(phrase))
+            return true;
+    }
+    // Generic 'so' / 'vậy' check — often used as 'so do X' or 'vậy làm X'
+    if (lower.startsWith("vậy ") || lower.startsWith("vay "))
+        return true;
+    // Pronoun-only path requires the prompt to be quite short (no concrete
+    // file/module name anywhere). "fix the auth flow" is NOT a follow-up;
+    // "fix it" IS. Bound at 40 chars to avoid false positives.
+    if (t.length <= 40 && CONTEXT_PRONOUN_RE.test(t))
+        return true;
+    return false;
+}
+//# sourceMappingURL=session-state.js.map

package/dist/src/pil/session-state.test.d.ts

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

package/dist/src/pil/session-state.test.js

@@ -0,0 +1,73 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { _resetForTests, bumpSessionTurn, getSessionState, isLikelyFollowUp, markDiscoveryAccepted, } from "./session-state.js";
+describe("session-state turn counter", () => {
+    beforeEach(() => _resetForTests());
+    afterEach(() => _resetForTests());
+    it("increments turnCount for each call per session", () => {
+        expect(bumpSessionTurn("s1")).toBe(1);
+        expect(bumpSessionTurn("s1")).toBe(2);
+        expect(bumpSessionTurn("s1")).toBe(3);
+        expect(getSessionState("s1")?.turnCount).toBe(3);
+    });
+    it("isolates counters per session", () => {
+        expect(bumpSessionTurn("a")).toBe(1);
+        expect(bumpSessionTurn("b")).toBe(1);
+        expect(bumpSessionTurn("a")).toBe(2);
+        expect(getSessionState("b")?.turnCount).toBe(1);
+    });
+    it("returns 1 and no-ops when sessionId is null/empty", () => {
+        expect(bumpSessionTurn(null)).toBe(1);
+        expect(bumpSessionTurn(undefined)).toBe(1);
+        expect(bumpSessionTurn("")).toBe(1);
+        expect(getSessionState(null)).toBeNull();
+    });
+    it("markDiscoveryAccepted records timestamp without resetting turnCount", () => {
+        bumpSessionTurn("s1");
+        bumpSessionTurn("s1");
+        markDiscoveryAccepted("s1", 12345);
+        const state = getSessionState("s1");
+        expect(state?.turnCount).toBe(2);
+        expect(state?.lastAcceptedDiscoveryAt).toBe(12345);
+    });
+});
+describe("isLikelyFollowUp", () => {
+    // Positive cases — these MUST be detected as follow-ups so PIL skips the
+    // interview askcard on turn >= 2.
+    it.each([
+        "Can you fix it?",
+        "can you fix harness failures ?",
+        "Could you try again?",
+        "please redo",
+        "now also fix the lint",
+        "what about the second one",
+        "try the other approach",
+        "redo with caching off",
+        "do it again",
+        "fix it",
+        "tiếp tục",
+        "làm tiếp",
+        "vậy thì sao",
+        "nó vẫn lỗi",
+    ])('matches follow-up: "%s"', (raw) => {
+        expect(isLikelyFollowUp(raw)).toBe(true);
+    });
+    // Negative cases — fresh task prompts should NOT be classified as follow-ups.
+    it.each([
+        "Add a new endpoint /api/users that returns the list of users with pagination support",
+        "Refactor src/foo.ts to use the new logger interface",
+        "Implement OAuth callback in src/auth/oauth.ts",
+        "", // empty
+        "  ", // whitespace only
+    ])('does NOT match: "%s"', (raw) => {
+        expect(isLikelyFollowUp(raw)).toBe(false);
+    });
+    it("does not match long prompts even when they start with 'can you'", () => {
+        const long = "can you walk me through how the harness E2E test framework works, including how spawnCostLeakHarness wires the mock model into the child TUI process";
+        expect(isLikelyFollowUp(long)).toBe(false);
+    });
+    it("does not match pronoun-bearing prompts when long enough to be a task description", () => {
+        // 'it' appears, but the prompt is detailed enough to stand on its own.
+        expect(isLikelyFollowUp("Refactor it to use a single shared interface across modules and packages")).toBe(false);
+    });
+});
+//# sourceMappingURL=session-state.test.js.map

package/dist/src/pil/task-tier-map.d.ts

@@ -19,7 +19,12 @@ export type EETier = "fast" | "balanced" | "premium";
 export declare function taskTypeToTier(taskType: string | null): EETier;
 /**
  * Map a PIL taskType to an appropriate maxOutputTokens budget.
- * Keeps conversational turns short and reserves headroom for generation-heavy tasks.
+ *
+ * PIL-L6 verbosity fix — budgets cut roughly in half from the prior values
+ * (debug 6K→3K, refactor 6K→4K, plan 8K→5K, generate 12K→8K, analyze 4K→2K,
+ * docs 4K→3K, default 4K→2K). Old values let "balanced" / "detailed" styles
+ * pad answers with end-of-turn summaries that users skip. Truncation at the
+ * tighter limit is preferable to bloat — agent will retry if it needs more.
  */
 export declare function taskTypeToMaxTokens(taskType: string | null): number;
 /**

package/dist/src/pil/task-tier-map.js

@@ -30,22 +30,29 @@ export function taskTypeToTier(taskType) {
 }
 /**
  * Map a PIL taskType to an appropriate maxOutputTokens budget.
- * Keeps conversational turns short and reserves headroom for generation-heavy tasks.
+ *
+ * PIL-L6 verbosity fix — budgets cut roughly in half from the prior values
+ * (debug 6K→3K, refactor 6K→4K, plan 8K→5K, generate 12K→8K, analyze 4K→2K,
+ * docs 4K→3K, default 4K→2K). Old values let "balanced" / "detailed" styles
+ * pad answers with end-of-turn summaries that users skip. Truncation at the
+ * tighter limit is preferable to bloat — agent will retry if it needs more.
  */
 export function taskTypeToMaxTokens(taskType) {
     switch (taskType) {
         case "analyze":
+            return 2_048;
         case "documentation":
-            return 4_096;
+            return 3_072;
         case "debug":
+            return 3_072;
         case "refactor":
-            return 6_144;
+            return 4_096;
         case "plan":
-            return 8_192;
+            return 5_120;
         case "generate":
-            return 12_288;
+            return 8_192;
         default:
-            return 4_096; // conversational — keep short
+            return 2_048; // conversational — keep short
     }
 }
 /**