@wizdear/atlas-code 0.2.4 → 0.2.6

package/dist/extension.js

@@ -1,13 +1,14 @@
 import { execFile } from "node:child_process";
-import { access, appendFile, mkdir, readdir, stat, writeFile } from "node:fs/promises";
-import { basename, join, relative } from "node:path";
+import { access, appendFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { getMarkdownTheme, ToolExecutionComponent, } from "@mariozechner/pi-coding-agent";
 import { Box, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { createRoleAgent, runAgent } from "./agent-factory.js";
 import { parseVibeCommand, STANDARD_TEMPLATES, VIBE_SUBCOMMANDS } from "./cli.js";
-import { extractQuestions, runDiscovery } from "./discovery.js";
+import { runDiscovery } from "./discovery.js";
 import { formatLogLine } from "./logger.js";
 import { runOrchestration } from "./orchestrator.js";
 import { PipelineRunner } from "./pipeline.js";
@@ -17,10 +18,11 @@ import { RetryManager } from "./retry.js";
 import { getSystemPromptForRole } from "./roles/index.js";
 import { createPipeline, inferWorkflowType, resolveFeatureWorkflowType } from "./router.js";
 import { enrichStandards } from "./standards-enricher.js";
-import { extractArtifactContent } from "./step-executor.js";
+import { aggregateUsage, extractArtifactContent } from "./step-executor.js";
 import { VibeStore } from "./store.js";
 import { runSystemArchitect } from "./system-architect.js";
 import { analyzeSystemDesignImpact, loadAllFeatureDesigns } from "./system-design-impact.js";
+import { createTelegramBridgeManager } from "./telegram/bridge.js";
 import { findUnmappedRequirements } from "./traceability.js";
 import { formatFeatureDetail, formatPipelineStatus, formatVibeEvent, VIBE_HELP } from "./ui.js";
 // ─── Chat Event Filter ──────────────────────────────────────────────────────
@@ -53,6 +55,16 @@ async function gitPush(cwd) {
         return false;
     }
 }
+/** Check if the cwd is inside a git repository. */
+async function isGitRepo(cwd) {
+    try {
+        await execFileAsync("git", ["rev-parse", "--git-dir"], { cwd });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** Check if a local git branch exists. */
 async function branchExists(cwd, branch) {
     try {
@@ -119,16 +131,21 @@ async function getFileMtime(filePath) {
         return null;
     }
 }
-// ─── QMD Cleanup ─────────────────────────────────────────────────────────────
-/** Remove stale QMD collections if qmd is installed. Silently skips if qmd is not available. */
-async function cleanupQmdCollections(cwd) {
+// ─── QMD Lifecycle ───────────────────────────────────────────────────────────
+/** Check if qmd CLI is available on the system. */
+async function isQmdInstalled() {
     try {
         await execFileAsync("which", ["qmd"]);
+        return true;
     }
     catch {
-        // qmd not installed — skip silently
-        return;
+        return false;
     }
+}
+/** Remove stale QMD collections if qmd is installed. Silently skips if qmd is not available. */
+async function cleanupQmdCollections(cwd) {
+    if (!(await isQmdInstalled()))
+        return;
     const indexName = basename(cwd);
     const collections = ["vibe-artifacts", "vibe-standards"];
     for (const col of collections) {
@@ -143,6 +160,52 @@ async function cleanupQmdCollections(cwd) {
         }
     }
 }
+/** Initialize QMD collection for .vibe/features/. Idempotent. */
+async function initQmdCollections(cwd) {
+    if (!(await isQmdInstalled()))
+        return;
+    const indexName = basename(cwd);
+    const env = { ...process.env, QMD_EMBED_MODEL: QMD_EMBED_MODEL_URI };
+    const featuresDir = join(cwd, ".vibe", "features");
+    try {
+        // Check if collection already exists
+        const { stdout } = await execFileAsync("qmd", ["--index", indexName, "collection", "list"], { cwd });
+        if (stdout.includes("vibe-artifacts"))
+            return;
+    }
+    catch {
+        // No collections yet — proceed with init
+    }
+    try {
+        await execFileAsync("qmd", ["--index", indexName, "collection", "add", featuresDir, "--name", "vibe-artifacts", "--mask", "**/*.md"], { cwd });
+        await execFileAsync("qmd", [
+            "--index",
+            indexName,
+            "context",
+            "add",
+            "qmd://vibe-artifacts",
+            "Feature artifacts: spec, design, review, test-report, diagnosis, impact-report",
+        ], { cwd });
+        await execFileAsync("qmd", ["--index", indexName, "embed"], { cwd, env });
+    }
+    catch {
+        // Silent failure — QMD is optional
+    }
+}
+/** Update QMD index with new/changed artifacts and regenerate embeddings. */
+async function updateQmdIndex(cwd) {
+    if (!(await isQmdInstalled()))
+        return;
+    const indexName = basename(cwd);
+    const env = { ...process.env, QMD_EMBED_MODEL: QMD_EMBED_MODEL_URI };
+    try {
+        await execFileAsync("qmd", ["--index", indexName, "update"], { cwd });
+        await execFileAsync("qmd", ["--index", indexName, "embed"], { cwd, env });
+    }
+    catch {
+        // Silent failure — QMD is optional
+    }
+}
 /** Minimal TUI stub for ToolExecutionComponent in renderer context. */
 const rendererTui = { requestRender: () => { } };
 /** Normalize agent tool result to ToolExecutionComponent format. */
@@ -182,6 +245,7 @@ function sendStepResultMessage(event, pipelineEditor, totalSteps) {
     const activityLog = pipelineEditor ? [...pipelineEditor.getActivityLog()] : [];
     const rawUsage = event.data?.usage;
     const usage = rawUsage && rawUsage.totalTokens > 0 ? rawUsage : undefined;
+    const responseText = event.data?.responseText;
     const content = failed
         ? `Step ${stepIndex + 1}: ${role} — ${event.step.action} (failed)`
         : `Step ${stepIndex + 1}: ${role} — ${event.step.action}`;
@@ -201,8 +265,17 @@ function sendStepResultMessage(event, pipelineEditor, totalSteps) {
             failed,
             error,
             usage,
+            responseText,
         },
     });
+    // Send agent response as a separate chat message so LLM output is always visible.
+    // Per-turn agent-text messages (from text_end events) may not fire when the model
+    // uses thinking blocks + tool calls without producing text content blocks.
+    // This ensures the final response text is always available in chat.
+    if (responseText) {
+        const lines = responseText.split("\n").length;
+        vibeAgentResponse(`${role} response (${lines} lines)`, responseText, usage);
+    }
 }
 // ─── QMD Skill Template ──────────────────────────────────────────────────────
 const QMD_EMBED_MODEL_URI = "hf:Qwen/Qwen3-Embedding-0.6B-GGUF/Qwen3-Embedding-0.6B-Q8_0.gguf";
@@ -237,15 +310,13 @@ PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
 INDEX_NAME=$(basename "$PROJECT_ROOT")
 qmd --index "$INDEX_NAME" status
 \`\`\`
-If no collections exist, initialize both artifacts and standards:
+If no collections exist, initialize the artifacts collection:
 \`\`\`bash
 export QMD_EMBED_MODEL="${QMD_EMBED_MODEL_URI}"
 PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
 INDEX_NAME=$(basename "$PROJECT_ROOT")
 qmd --index "$INDEX_NAME" collection add "$PROJECT_ROOT/.vibe/features" --name vibe-artifacts --mask "**/*.md"
 qmd --index "$INDEX_NAME" context add qmd://vibe-artifacts "Feature artifacts: spec, design, review, test-report, diagnosis, impact-report"
-qmd --index "$INDEX_NAME" collection add "$PROJECT_ROOT/.vibe/standards" --name vibe-standards --mask "**/*.md"
-qmd --index "$INDEX_NAME" context add qmd://vibe-standards "Project coding standards, architecture principles, testing policies"
 qmd --index "$INDEX_NAME" embed
 \`\`\`
 
@@ -258,12 +329,6 @@ export QMD_EMBED_MODEL="${QMD_EMBED_MODEL_URI}"
 INDEX_NAME=$(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
 qmd --index "$INDEX_NAME" search "<keywords>" -c vibe-artifacts -n 5 --min-score 0.3 --json
 \`\`\`
-Search coding standards:
-\`\`\`bash
-export QMD_EMBED_MODEL="${QMD_EMBED_MODEL_URI}"
-INDEX_NAME=$(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
-qmd --index "$INDEX_NAME" search "<keywords>" -c vibe-standards -n 5 --min-score 0.3 --json
-\`\`\`
 If results are returned, read the referenced files and factor past decisions into current work.
 
 ### During Review
@@ -291,6 +356,9 @@ qmd --index "$INDEX_NAME" embed
 // ─── Session Message Helper ──────────────────────────────────────────────────
 /** Extension API reference. Set by the vibeExtension factory. */
 let _pi;
+/** Shared Telegram command registry. Commands are pushed here during factory setup
+ *  and read by the bridge polling loop (which starts later during session_start). */
+const _telegramCommands = [];
 // ─── Agent Response Preview ──────────────────────────────────────────────────
 /** Number of preview lines shown when agent-response is collapsed. */
 export const AGENT_RESPONSE_PREVIEW_LINES = 5;
@@ -307,13 +375,17 @@ export function computeAgentResponsePreview(fullText, maxLines = AGENT_RESPONSE_
     return { preview, remaining: allLines.length - maxLines };
 }
 /** Sends a categorized vibe message to the session. */
-function sendVibeMessage(content, category, fullText) {
+function sendVibeMessage(content, category, fullText, usage) {
     _pi.sendMessage({
         customType: "vibe",
         content,
         display: true,
-        details: { category, fullText },
+        details: { category, fullText, usage },
     });
+    // Also emit via EventBus so the Telegram bridge can receive it.
+    // pi.sendMessage() → sendCustomMessage() only fires _emit() (TUI listeners),
+    // not _emitExtensionEvent(), so pi.on("message_end") never fires for custom messages.
+    _pi.events?.emit("vibe:message", { content, category, fullText, usage });
 }
 function vibeCommand(text) {
     sendVibeMessage(text, "command");
@@ -333,8 +405,23 @@ function vibeGate(text) {
 function vibeEvent(text) {
     sendVibeMessage(text, "event");
 }
-function vibeAgentResponse(summary, fullText) {
-    sendVibeMessage(summary, "agent-response", fullText);
+function vibeAgentResponse(summary, fullText, usage) {
+    sendVibeMessage(summary, "agent-response", fullText, usage);
+}
+/**
+ * Wait for gate choice from TUI select() or Telegram inline keyboard.
+ * Whichever responds first wins; the other is dismissed.
+ */
+async function waitForGateChoice(events, ui, summary, options) {
+    const abortController = new AbortController();
+    let telegramChoice;
+    const unsubGateResponse = events.on("vibe:gate_response", (raw) => {
+        telegramChoice = raw.choice;
+        abortController.abort();
+    });
+    const tuiChoice = await ui.select(summary, options, { signal: abortController.signal });
+    unsubGateResponse();
+    return tuiChoice ?? telegramChoice;
 }
 /**
  * Forwards only chat-visible events as vibeMessages.
@@ -463,8 +550,42 @@ function formatToolResult(toolName, args, result, isError, projectRoot) {
  * Creates a handler that displays agent event progress in PipelineEditorComponent (or status bar).
  * Uses the editor when active; falls back to the status bar otherwise.
  */
+/** Extracts the last non-empty line from an AssistantMessage's text content. */
+function getLastNonEmptyLine(partial) {
+    for (let i = partial.content.length - 1; i >= 0; i--) {
+        const c = partial.content[i];
+        if (c.type === "text") {
+            const lines = c.text.split("\n");
+            for (let j = lines.length - 1; j >= 0; j--) {
+                const trimmed = lines[j].trim();
+                if (trimmed)
+                    return trimmed;
+            }
+        }
+    }
+    return undefined;
+}
+/** Extract the last N non-empty lines from a partial assistant message. */
+function getLastNonEmptyLines(partial, maxLines) {
+    const allLines = [];
+    for (const c of partial.content) {
+        if (c.type === "text") {
+            for (const line of c.text.split("\n")) {
+                const trimmed = line.trim();
+                if (trimmed)
+                    allLines.push(trimmed);
+            }
+        }
+    }
+    if (allLines.length === 0)
+        return undefined;
+    return allLines.slice(-maxLines).join("\n");
+}
+/** Throttle interval for LLM streaming detail updates (ms). */
+const STREAMING_THROTTLE_MS = 100;
 function createAgentProgressHandler(ctx, label, pipelineEditor, projectRoot) {
     const pendingArgs = new Map();
+    let lastDetailUpdate = 0;
     return (event) => {
         if (event.type === "tool_execution_start") {
             const args = event.args;
@@ -495,40 +616,62 @@ function createAgentProgressHandler(ctx, label, pipelineEditor, projectRoot) {
                 },
             });
         }
+        if (event.type === "message_update") {
+            const ame = event.assistantMessageEvent;
+            const now = Date.now();
+            if (ame.type === "text_delta" || ame.type === "text_end") {
+                if (now - lastDetailUpdate < STREAMING_THROTTLE_MS && ame.type !== "text_end")
+                    return;
+                lastDetailUpdate = now;
+                if (pipelineEditor) {
+                    // Show last N lines in the pipeline editor box
+                    const recentLines = getLastNonEmptyLines(ame.partial, 6);
+                    if (recentLines) {
+                        pipelineEditor.setDetail(`✎ ${recentLines}`);
+                    }
+                }
+                else {
+                    const lastLine = getLastNonEmptyLine(ame.partial);
+                    if (lastLine) {
+                        ctx.ui.setStatus("vibe", `${label}: ✎ ${lastLine}`);
+                    }
+                }
+                // On text_end, send completed text block to chat
+                if (ame.type === "text_end") {
+                    const completedText = ame.content.trim();
+                    if (completedText) {
+                        const lines = completedText.split("\n").length;
+                        sendVibeMessage(`[${label}] ✎ (${lines} lines)`, "agent-text", completedText);
+                    }
+                }
+            }
+            if (ame.type === "thinking_delta" || ame.type === "thinking_start") {
+                if (now - lastDetailUpdate < STREAMING_THROTTLE_MS && ame.type !== "thinking_start")
+                    return;
+                lastDetailUpdate = now;
+                if (pipelineEditor) {
+                    pipelineEditor.setDetail("thinking...");
+                }
+                else {
+                    ctx.ui.setStatus("vibe", `${label}: thinking...`);
+                }
+            }
+            if (ame.type === "done") {
+                const msg = ame.message;
+                if (msg.usage && msg.usage.totalTokens > 0) {
+                    const fmt = (n) => n.toLocaleString("en-US");
+                    const tokenInfo = `tokens: ${fmt(msg.usage.input)} in / ${fmt(msg.usage.output)} out`;
+                    if (pipelineEditor) {
+                        pipelineEditor.addActivity(tokenInfo);
+                    }
+                }
+            }
+        }
     };
 }
 function createAbortHandle() {
     return { aborted: false };
 }
-// ─── Skill Discovery ─────────────────────────────────────────────────────────
-/**
- * Scans .vibe/skills/ and builds a lightweight index of available skills.
- * Contains only each skill's name, description, and file path.
- * Agents load the full content via the read tool when needed.
- */
-async function buildAvailableSkillsPrompt(store) {
-    const skills = await store.listSkills();
-    if (skills.length === 0)
-        return "";
-    const entries = [];
-    for (const skillName of skills) {
-        const description = await store.readSkillDescription(skillName);
-        if (description) {
-            const skillPath = `.vibe/skills/${skillName}/SKILL.md`;
-            entries.push(`- **${skillName}** (${skillPath}): ${description}`);
-        }
-    }
-    if (entries.length === 0)
-        return "";
-    return [
-        "## Available Skills",
-        "",
-        "The following skills provide specialized instructions for this project.",
-        "Use the read tool to load a skill's SKILL.md when your current task matches its description.",
-        "",
-        ...entries,
-    ].join("\n");
-}
 // ─── Pipeline Editor Helpers ──────────────────────────────────────────────────
 /**
  * Activates the pipeline editor by replacing the default editor with PipelineEditorComponent.
@@ -585,10 +728,12 @@ function pipelineStepsToInfo(pipeline) {
 function createEditorAgentCallbacks(pipelineEditor, projectRoot, abortHandle, stepContext) {
     let unsubscribe;
     const pendingArgs = new Map();
+    let lastDetailUpdate = 0;
     return {
         onAgentCreated: (agent) => {
             unsubscribe?.();
             pendingArgs.clear();
+            lastDetailUpdate = 0;
             if (abortHandle) {
                 abortHandle.currentAgent = agent;
             }
@@ -598,12 +743,14 @@ function createEditorAgentCallbacks(pipelineEditor, projectRoot, abortHandle, st
                     pendingArgs.set(event.toolCallId, args);
                     const detail = formatToolProgress(event.toolName, args, projectRoot);
                     pipelineEditor.addActivity(detail);
+                    _pi.events.emit("vibe:activity", { role: stepContext?.role ?? "", text: detail, type: "tool" });
                 }
                 if (event.type === "tool_execution_end") {
                     const args = pendingArgs.get(event.toolCallId) ?? {};
                     pendingArgs.delete(event.toolCallId);
                     const summary = formatToolResult(event.toolName, args, event.result, event.isError, projectRoot);
                     pipelineEditor.addActivity(summary);
+                    _pi.events.emit("vibe:activity", { role: stepContext?.role ?? "", text: summary, type: "tool_result" });
                     // Send tool execution to chat for ToolExecutionComponent rendering
                     if (stepContext) {
                         const label = formatToolProgress(event.toolName, args, projectRoot);
@@ -622,6 +769,46 @@ function createEditorAgentCallbacks(pipelineEditor, projectRoot, abortHandle, st
                         });
                     }
                 }
+                if (event.type === "message_update") {
+                    const ame = event.assistantMessageEvent;
+                    const now = Date.now();
+                    if (ame.type === "thinking_start") {
+                        pipelineEditor.addActivity("thinking...");
+                    }
+                    if (ame.type === "text_delta" || ame.type === "text_end") {
+                        if (now - lastDetailUpdate < STREAMING_THROTTLE_MS && ame.type !== "text_end")
+                            return;
+                        lastDetailUpdate = now;
+                        const lastLine = getLastNonEmptyLine(ame.partial);
+                        if (lastLine) {
+                            const entry = `✎ ${lastLine}`;
+                            const log = pipelineEditor.getActivityLog();
+                            const last = log[log.length - 1];
+                            if (last?.startsWith("✎")) {
+                                pipelineEditor.updateLastActivity(entry);
+                            }
+                            else {
+                                pipelineEditor.addActivity(entry);
+                            }
+                            _pi.events.emit("vibe:activity", { role: stepContext?.role ?? "", text: entry, type: "text" });
+                        }
+                        if (ame.type === "text_end" && stepContext) {
+                            const completedText = ame.content.trim();
+                            if (completedText) {
+                                const lines = completedText.split("\n").length;
+                                sendVibeMessage(`[${stepContext.role}] ✎ (${lines} lines)`, "agent-text", completedText);
+                            }
+                        }
+                    }
+                    if (ame.type === "done") {
+                        const msg = ame.message;
+                        if (msg.usage && msg.usage.totalTokens > 0) {
+                            const fmt = (n) => n.toLocaleString("en-US");
+                            const tokenInfo = `tokens: ${fmt(msg.usage.input)} in / ${fmt(msg.usage.output)} out`;
+                            pipelineEditor.addActivity(tokenInfo);
+                        }
+                    }
+                }
             });
         },
         onAgentFinished: () => {
@@ -682,15 +869,19 @@ async function runStandardsEnrichment(store, ctx, config, source, abortHandle, p
             context = parts.join("\n\n---\n\n");
         }
         else {
-            const requirements = await store.readRequirements();
+            const parts = [];
+            parts.push(await store.readRequirements());
             const plan = await store.loadPlan();
-            const specs = [];
+            parts.push(JSON.stringify(plan, null, 2));
             for (const feature of plan.features) {
                 if (await store.hasArtifact(feature.featureId, "spec.md")) {
-                    specs.push(await store.readArtifact(feature.featureId, "spec.md"));
+                    parts.push(await store.readArtifact(feature.featureId, "spec.md"));
                 }
             }
-            context = [requirements, JSON.stringify(plan, null, 2), ...specs].join("\n\n---\n\n");
+            if (await store.hasSystemDesign()) {
+                parts.push(await store.readSystemDesign());
+            }
+            context = parts.join("\n\n---\n\n");
         }
     }
     catch {
@@ -718,6 +909,10 @@ async function runStandardsEnrichment(store, ctx, config, source, abortHandle, p
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("aborted")) {
+            // Abort errors are not re-thrown. The caller checks abortHandle.aborted.
+            return;
+        }
         vibeWarning(`Standards enrichment failed: ${msg}`);
     }
 }
@@ -747,26 +942,17 @@ async function runDocumenter(store, ctx, config, completedFeatures, pipelineEdit
     const specList = specPaths.length > 0
         ? `The following feature specs were completed:\n${specPaths.map((p) => `- ${p}`).join("\n")}`
         : "No feature specs available.";
-    const projectContextPath = join(ctx.cwd, ".vibe", "project-context.md");
-    let existingContext = "";
-    try {
-        existingContext = await store.readProjectContext();
-    }
-    catch {
-        // Empty string if project-context.md doesn't exist
-    }
-    const contextInfo = existingContext
-        ? `Existing project-context.md:\n\`\`\`\n${existingContext}\n\`\`\``
-        : `No existing project-context.md found at ${projectContextPath}. Create one from scratch by exploring the project.`;
-    const prompt = [
-        `Update the project documentation for the project at "${ctx.cwd}".`,
-        "",
-        specList,
-        "",
-        contextInfo,
-        "",
-        "Follow your instructions: update project-context.md, update/create README.md, and output a Getting Started summary.",
-    ].join("\n");
+    // Build feature metadata for Completed Features table
+    const featureMetadata = completedFeatures.map((fId) => `- ${fId} (${inferWorkflowType(fId)})`);
+    const featureInfo = featureMetadata.length > 0
+        ? `Add these features to the Completed Features table in project-context.md:\n${featureMetadata.join("\n")}`
+        : "";
+    const promptParts = [`Update the project documentation for the project at "${ctx.cwd}".`, "", specList];
+    if (featureInfo) {
+        promptParts.push("", featureInfo);
+    }
+    promptParts.push("", "Follow your instructions: update project-context.md, update/create README.md, and output a Getting Started summary.");
+    const prompt = promptParts.join("\n");
     // Create and run documenter agent
     const systemPrompt = getSystemPromptForRole("documenter");
     const agent = await createRoleAgent({
@@ -783,6 +969,9 @@ async function runDocumenter(store, ctx, config, completedFeatures, pipelineEdit
         response = await runAgent(agent, prompt, {
             onEvent: createAgentProgressHandler(ctx, "Documenting", pipelineEditor, ctx.cwd),
         });
+        const documenterUsage = aggregateUsage(agent.state.messages);
+        const documenterLines = response.split("\n").length;
+        vibeAgentResponse(`Documenter response (${documenterLines} lines)`, response, documenterUsage);
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
@@ -794,12 +983,6 @@ async function runDocumenter(store, ctx, config, completedFeatures, pipelineEdit
     }
     if (abortHandle.aborted)
         return;
-    // Extract Getting Started summary and display in chat
-    const gettingStarted = extractArtifactContent(response, "getting-started", false);
-    if (gettingStarted) {
-        const lines = gettingStarted.split("\n").length;
-        vibeAgentResponse(`Getting Started summary (${lines} lines)`, gettingStarted);
-    }
     vibeMilestone("Documentation updated");
 }
 // ─── Workflow Titles ──────────────────────────────────────────────────────────
@@ -818,9 +1001,37 @@ const activePipelines = new Map();
 function formatElapsed(ms) {
     return ms >= 1000 ? `${(ms / 1000).toFixed(1)}s` : `${ms}ms`;
 }
+/** Formats token usage as a compact string for headers. */
+export function formatTokenUsage(usage) {
+    const fmt = (n) => n.toLocaleString("en-US");
+    return `[${fmt(usage.input)} in / ${fmt(usage.output)} out]`;
+}
+/** npm package name for update checks. */
+const AC_PACKAGE_NAME = "@wizdear/atlas-code";
+/** Check npm registry for a newer version of Atlas Code. */
+async function checkForAcUpdate(currentVersion) {
+    if (process.env.PI_SKIP_VERSION_CHECK || process.env.PI_OFFLINE)
+        return undefined;
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${AC_PACKAGE_NAME}/latest`, {
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok)
+            return undefined;
+        const data = (await response.json());
+        if (data.version && data.version !== currentVersion)
+            return data.version;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Vibe Engineering Extension factory. */
 export const vibeExtension = (pi) => {
     _pi = pi;
+    // Suppress pi's built-in update check — Atlas Code has its own
+    process.env.PI_SKIP_VERSION_CHECK = "1";
     // Register custom renderer for vibe-tool messages (agent tool executions)
     pi.registerMessageRenderer("vibe-tool", (message, { expanded }, _theme) => {
         const details = message.details;
@@ -842,7 +1053,8 @@ export const vibeExtension = (pi) => {
         const elapsed = formatElapsed(details.elapsed);
         const marker = details.failed ? theme.fg("error", "✗") : theme.fg("success", "✓");
         const suffix = details.failed ? theme.fg("error", "(failed)") : theme.fg("dim", `(${elapsed})`);
-        const header = `${marker} Step ${details.stepIndex + 1}/${details.totalSteps}: ${role} — ${details.action} ${suffix}`;
+        const tokenSuffix = details.usage && details.usage.totalTokens > 0 ? ` ${theme.fg("dim", formatTokenUsage(details.usage))}` : "";
+        const header = `${marker} Step ${details.stepIndex + 1}/${details.totalSteps}: ${role} — ${details.action} ${suffix}${tokenSuffix}`;
         const box = new Box(1, 1, (t) => theme.bg("customMessageBg", t));
         box.addChild(new Text(header, 0, 0));
         if (expanded) {
@@ -866,6 +1078,16 @@ export const vibeExtension = (pi) => {
                 }
                 box.addChild(new Text(theme.fg("dim", tokenLine), 0, 0));
             }
+            if (details.responseText) {
+                box.addChild(new Spacer(1));
+                const { preview, remaining } = computeAgentResponsePreview(details.responseText);
+                box.addChild(new Markdown(preview, 0, 0, mdTheme, {
+                    color: (t) => theme.fg("customMessageText", t),
+                }));
+                if (remaining > 0) {
+                    box.addChild(new Text(theme.fg("dim", `... (${remaining} more lines)`), 0, 0));
+                }
+            }
         }
         return box;
     });
@@ -919,7 +1141,10 @@ export const vibeExtension = (pi) => {
             }
             case "agent-response": {
                 const marker = expanded ? "▼" : "▶";
-                box.addChild(new Text(`${marker} ${content}`, 0, 0));
+                const usageSuffix = details?.usage && details.usage.totalTokens > 0
+                    ? ` ${theme.fg("dim", formatTokenUsage(details.usage))}`
+                    : "";
+                box.addChild(new Text(`${marker} ${content}${usageSuffix}`, 0, 0));
                 if (details?.fullText) {
                     box.addChild(new Spacer(1));
                     if (expanded) {
@@ -939,6 +1164,29 @@ export const vibeExtension = (pi) => {
                 }
                 break;
             }
+            case "agent-text": {
+                const atMarker = expanded ? "▼" : "▶";
+                box.addChild(new Text(theme.fg("dim", `${atMarker} ${content}`), 0, 0));
+                if (details?.fullText) {
+                    if (expanded) {
+                        box.addChild(new Spacer(1));
+                        box.addChild(new Markdown(details.fullText, 0, 0, mdTheme, {
+                            color: (t) => theme.fg("customMessageText", t),
+                        }));
+                    }
+                    else {
+                        const { preview, remaining } = computeAgentResponsePreview(details.fullText);
+                        box.addChild(new Spacer(1));
+                        box.addChild(new Markdown(preview, 0, 0, mdTheme, {
+                            color: (t) => theme.fg("dim", t),
+                        }));
+                        if (remaining > 0) {
+                            box.addChild(new Text(theme.fg("dim", `... (${remaining} more lines)`), 0, 0));
+                        }
+                    }
+                }
+                break;
+            }
             case "event": {
                 box.addChild(new Text(theme.fg("dim", content), 0, 0));
                 break;
@@ -946,6 +1194,192 @@ export const vibeExtension = (pi) => {
         }
         return box;
     });
+    // Register custom renderer for vibe-update messages (Atlas Code update notification)
+    pi.registerMessageRenderer("vibe-update", (message, _options, theme) => {
+        const details = message.details;
+        if (!details)
+            return undefined;
+        const w = (t) => theme.fg("warning", t);
+        const a = (t) => theme.fg("accent", t);
+        const m = (t) => theme.fg("muted", t);
+        const border = w("─".repeat(75));
+        const header = theme.bold(w("Update Available"));
+        const instruction = `${m(`New version ${details.newVersion} is available. `)}${a(`Run: npm install -g ${AC_PACKAGE_NAME}`)}`;
+        const box = new Box(0, 0);
+        box.addChild(new Text(border, 0, 0));
+        box.addChild(new Text(` ${header}`, 0, 0));
+        box.addChild(new Text(` ${instruction}`, 0, 0));
+        box.addChild(new Text(border, 0, 0));
+        return box;
+    });
+    // ── Custom Header ────────────────────────────────────────────────────────
+    pi.on("session_start", async (_event, ctx) => {
+        if (ctx.hasUI) {
+            // Read version from package.json
+            let acVersion = "0.0.0";
+            try {
+                const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+                const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+                acVersion = pkg.version ?? acVersion;
+            }
+            catch {
+                // Fallback version
+            }
+            // Check for Atlas Code updates asynchronously
+            checkForAcUpdate(acVersion).then((newVersion) => {
+                if (newVersion) {
+                    _pi.sendMessage({
+                        customType: "vibe-update",
+                        content: newVersion,
+                        display: true,
+                        details: { currentVersion: acVersion, newVersion },
+                    });
+                }
+            });
+            ctx.ui.setHeader((_tui, theme) => ({
+                render(_width) {
+                    const b = (t) => theme.fg("accent", t);
+                    const d = (t) => theme.fg("dim", t);
+                    // Atlas Code logo — diamond with digital glitch
+                    const logo = [
+                        `   ${b("░▒▓")}  ${b("╱╲")}  ${b("▓▒░")}`,
+                        `    ${b("▓█")} ${b("╱  ╲")} ${b("█▓")}`,
+                        `    ${b("█▓")} ${b("╲  ╱")} ${b("▓█")}`,
+                        `   ${b("░▒▓")}  ${b("╲╱")}  ${b("▓▒░")}`,
+                    ];
+                    const title = `  ${theme.bold("Atlas Code")} ${d(`v${acVersion}`)}`;
+                    const vibeCommands = [
+                        `  ${d("── Vibe Commands ─────────────────────────────────────")}`,
+                        "",
+                        `  ${d("Setup")}`,
+                        `    ${d("/vibe init")}                      Initialize .vibe/ directory`,
+                        "",
+                        `  ${d("Start Workflow")}`,
+                        `    ${d("/vibe <requirements>")}            Auto workflow`,
+                        `    ${d("/vibe new <requirements>")}        New feature`,
+                        `    ${d("/vibe enhance <id> <req>")}        Enhance existing feature`,
+                        `    ${d("/vibe fix <description>")}         Fix a bug`,
+                        `    ${d("/vibe refactor <id> <purpose>")}   Refactor a feature`,
+                        "",
+                        `  ${d("Monitor & Control")}`,
+                        `    ${d("/vibe status")}                    Show pipeline status`,
+                        `    ${d("/vibe resume <id>")}               Resume paused pipeline`,
+                    ];
+                    const keybindings = [
+                        `  ${d("── Keybindings ───────────────────────────────────────")}`,
+                        `  ${d("ctrl+c to interrupt, ctrl+l to clear, ctrl+l twice to exit")}`,
+                        `  ${d("ctrl+d to exit (empty), ctrl+z to suspend")}`,
+                        `  ${d("ctrl+k to delete to end, ctrl+t to cycle thinking level")}`,
+                        `  ${d("ctrl+p/ctrl+n to cycle models, ctrl+shift+p to select model")}`,
+                        `  ${d("ctrl+e to expand tools, ctrl+shift+e to expand thinking")}`,
+                        `  ${d("ctrl+o for external editor, / for commands")}`,
+                        `  ${d("! to run bash, !! to run bash (no context)")}`,
+                        `  ${d("ctrl+f to queue follow-up, ctrl+shift+f to edit queued messages")}`,
+                        `  ${d("ctrl+v to paste image, drop files to attach")}`,
+                    ];
+                    return ["", ...logo, "", title, "", ...vibeCommands, "", ...keybindings, ""];
+                },
+                invalidate() { },
+            }));
+        }
+        // Telegram bridge — auto-activate from env vars or .vibe/config.json
+        const vibeDir = join(ctx.cwd, ".vibe");
+        const bridgeManager = createTelegramBridgeManager(pi, ctx, vibeDir, _telegramCommands);
+        bridgeManager.tryStart();
+        pi.on("agent_end", () => {
+            bridgeManager.tryStart();
+        });
+        pi.on("session_shutdown", () => {
+            bridgeManager.stop();
+        });
+    });
+    // Telegram bridge setup guidance in system prompt
+    pi.on("before_agent_start", (event) => {
+        const telegramGuideline = [
+            "",
+            "## Telegram Bridge",
+            "This project has a built-in Telegram bridge. When the user asks to connect/setup Telegram:",
+            '1. Write the bot token to `.vibe/config.json` under `telegram.token` (e.g., `{ "telegram": { "token": "..." } }`). Merge with existing config if the file already exists.',
+            "2. Do NOT create a Telegram bot project, install npm packages, or write bot code.",
+            "3. The bridge activates automatically after the config is saved. Chat ID is auto-discovered from the first message sent to the bot.",
+        ].join("\n");
+        return { systemPrompt: `${event.systemPrompt}${telegramGuideline}` };
+    });
+    const vibeCommandHandler = async (args, ctx) => {
+        try {
+            const command = parseVibeCommand(args);
+            // Record user command input in session
+            if (command.type !== "help") {
+                vibeCommand(`/vibe ${args.trim() || command.type}`);
+            }
+            const logger = createVibeLogger(ctx, join(ctx.cwd, ".vibe"));
+            const store = new VibeStore(ctx.cwd, logger);
+            switch (command.type) {
+                case "help":
+                    ctx.ui.notify(VIBE_HELP, "info");
+                    break;
+                case "init":
+                    await handleInit(store, ctx);
+                    break;
+                case "reset":
+                    await handleReset(store, ctx);
+                    break;
+                case "recover":
+                    await handleRecover(store, ctx);
+                    break;
+                case "analyze":
+                    await handleAnalyze(store, ctx, ctx.model);
+                    break;
+                case "config":
+                    await handleConfig(store, ctx);
+                    break;
+                case "status":
+                    await handleStatus(store, ctx, command.featureId);
+                    break;
+                case "log":
+                    await handleLog(store, ctx, command.featureId);
+                    break;
+                case "auto":
+                    await handleWorkflow(store, ctx, "auto", command.requirement, undefined, logger);
+                    break;
+                case "new":
+                    await handleWorkflow(store, ctx, "new_feature", command.requirement, undefined, logger);
+                    break;
+                case "enhance":
+                    await handleWorkflow(store, ctx, "enhancement", command.requirement, { parentFeatureId: command.featureId }, logger);
+                    break;
+                case "fix":
+                    await handleWorkflow(store, ctx, "bugfix", command.description, { issueRef: command.issueRef }, logger);
+                    break;
+                case "refactor":
+                    await handleWorkflow(store, ctx, "refactor", command.purpose, { parentFeatureId: command.featureId }, logger);
+                    break;
+                case "pause":
+                    await handlePause(command.featureId, ctx);
+                    break;
+                case "resume":
+                    await handleResume(store, ctx, command.featureId, logger);
+                    break;
+                case "steer": {
+                    const active = activePipelines.get(command.featureId);
+                    if (!active?.activeAgent) {
+                        ctx.ui.notify(`[Vibe] No running agent for ${command.featureId}`, "warning");
+                        break;
+                    }
+                    active.activeAgent.steer({
+                        role: "user",
+                        content: [{ type: "text", text: command.feedback }],
+                        timestamp: Date.now(),
+                    });
+                    ctx.ui.notify(`[Steer] Feedback sent to ${command.featureId}`, "info");
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            vibeError(error instanceof Error ? error.message : String(error));
+        }
+    };
     pi.registerCommand("vibe", {
         description: "AI Vibe Engineering System",
         getArgumentCompletions(argumentPrefix) {
@@ -957,96 +1391,52 @@ export const vibeExtension = (pi) => {
             }
             return null;
         },
-        async handler(args, ctx) {
-            try {
-                const command = parseVibeCommand(args);
-                // Record user command input in session
-                if (command.type !== "help") {
-                    vibeCommand(`/vibe ${args.trim() || command.type}`);
-                }
-                const logger = createVibeLogger(ctx, join(ctx.cwd, ".vibe"));
-                const store = new VibeStore(ctx.cwd, logger);
-                switch (command.type) {
-                    case "help":
-                        ctx.ui.notify(VIBE_HELP, "info");
-                        break;
-                    case "init":
-                        await handleInit(store, ctx);
-                        break;
-                    case "analyze":
-                        await handleAnalyze(store, ctx, ctx.model);
-                        break;
-                    case "config":
-                        await handleConfig(store, ctx);
-                        break;
-                    case "status":
-                        await handleStatus(store, ctx, command.featureId);
-                        break;
-                    case "log":
-                        await handleLog(store, ctx, command.featureId);
-                        break;
-                    case "auto":
-                        await handleWorkflow(store, ctx, "auto", command.requirement, undefined, logger);
-                        break;
-                    case "new":
-                        await handleWorkflow(store, ctx, "new_feature", command.requirement, undefined, logger);
-                        break;
-                    case "enhance":
-                        await handleWorkflow(store, ctx, "enhancement", command.requirement, { parentFeatureId: command.featureId }, logger);
-                        break;
-                    case "fix":
-                        await handleWorkflow(store, ctx, "bugfix", command.description, { issueRef: command.issueRef }, logger);
-                        break;
-                    case "refactor":
-                        await handleWorkflow(store, ctx, "refactor", command.purpose, { parentFeatureId: command.featureId }, logger);
-                        break;
-                    case "pause":
-                        await handlePause(command.featureId, ctx);
-                        break;
-                    case "resume":
-                        await handleResume(store, ctx, command.featureId, logger);
-                        break;
-                    case "steer": {
-                        const active = activePipelines.get(command.featureId);
-                        if (!active?.activeAgent) {
-                            ctx.ui.notify(`[Vibe] No running agent for ${command.featureId}`, "warning");
-                            break;
-                        }
-                        active.activeAgent.steer({
-                            role: "user",
-                            content: [{ type: "text", text: command.feedback }],
-                            timestamp: Date.now(),
-                        });
-                        ctx.ui.notify(`[Steer] Feedback sent to ${command.featureId}`, "info");
-                        break;
-                    }
-                }
-            }
-            catch (error) {
-                vibeError(error instanceof Error ? error.message : String(error));
-            }
-        },
+        handler: vibeCommandHandler,
+    });
+    // Register vibe command for Telegram dispatch (shared array, read by bridge polling loop)
+    _telegramCommands.push({
+        name: "vibe",
+        description: "AI Vibe Engineering System",
+        handler: vibeCommandHandler,
+        subcommands: [
+            { name: "new", description: "Start a new feature" },
+            { name: "enhance", description: "Enhance existing feature" },
+            { name: "fix", description: "Fix a bug" },
+            { name: "refactor", description: "Refactor code" },
+            { name: "status", description: "Show pipeline status" },
+            { name: "resume", description: "Resume paused pipeline" },
+            { name: "pause", description: "Pause current pipeline" },
+            { name: "config", description: "Configure vibe settings" },
+            { name: "log", description: "Show pipeline log" },
+            { name: "steer", description: "Steer active pipeline" },
+            { name: "analyze", description: "Analyze project" },
+            { name: "init", description: "Initialize vibe project" },
+            { name: "reset", description: "Reset vibe state" },
+            { name: "recover", description: "Recover from failed state" },
+        ],
     });
     // ── vibe_start tool ──────────────────────────────────────────────────────
     //
     // Allows the LLM to invoke the vibe pipeline programmatically.
     //
-    // sendUserMessage() bypasses command routing (expandPromptTemplates: false
-    // in agent-session.js), so we cannot delegate via "/vibe" as a user message.
+    // The tool stores the requirement and defers execution to agent_end.
+    // This ensures handleWorkflow() runs AFTER the main agent finishes streaming,
+    // so _pi.sendMessage() calls go through appendMessage() instead of
+    // agent.steer(). Without this, display-only progress messages would enter
+    // the steering queue, skip remaining tool calls, and pollute the main
+    // agent's LLM context (custom messages are converted to role:"user" by
+    // convertToLlm, causing the main agent to respond to pipeline progress).
     //
-    // Instead: tool stores the requirement, sends a trigger phrase as a followUp.
-    // The input event handler intercepts the trigger before it reaches the queue,
-    // returns "handled", and calls handleWorkflow() directly.
-    //
-    // Triple guard against duplicate execution (LLM batches tool calls):
+    // Duplicate execution guard:
     // 1. vibeStartFired flag in execute() — second call returns immediately
-    // 2. Input handler absorbs orphan triggers (no pending requirement)
-    // 3. agent_end skips tool re-activation while vibeStartFired is true
+    // 2. agent_end clears the flag after workflow completes
     let pendingVibeRequirement;
     let vibeStartFired = false;
-    const VIBE_TRIGGER = "__vibe_pipeline_start__";
-    pi.on("input", async (event, ctx) => {
-        if (event.text === VIBE_TRIGGER && pendingVibeRequirement) {
+    pi.on("agent_end", async (_event, ctx) => {
+        // Start the pipeline after the main agent finishes streaming.
+        // At this point isStreaming === false, so _pi.sendMessage() calls
+        // use appendMessage() instead of agent.steer().
+        if (pendingVibeRequirement) {
             const requirement = pendingVibeRequirement;
             pendingVibeRequirement = undefined;
             // Cast ctx to ExtensionCommandContext — safe because handleWorkflow
@@ -1065,14 +1455,8 @@ export const vibeExtension = (pi) => {
             finally {
                 vibeStartFired = false;
             }
-            return { action: "handled" };
-        }
-        // Absorb duplicate trigger messages from batched tool calls
-        if (event.text === VIBE_TRIGGER) {
-            return { action: "handled" };
+            return;
         }
-    });
-    pi.on("agent_end", async () => {
         // Re-activate vibe_start only after the pipeline has completed
         if (!vibeStartFired) {
             const activeTools = pi.getActiveTools();
@@ -1106,7 +1490,6 @@ export const vibeExtension = (pi) => {
             }
             vibeStartFired = true;
             pendingVibeRequirement = params.description;
-            pi.sendUserMessage(VIBE_TRIGGER, { deliverAs: "followUp" });
             const activeTools = pi.getActiveTools();
             pi.setActiveTools(activeTools.filter((t) => t !== "vibe_start"));
             return {
@@ -1135,17 +1518,19 @@ async function handleInit(store, ctx) {
             await writeFile(filePath, content, "utf-8");
         }
     }
-    // Create QMD memory skill template
-    const qmdSkillPath = join(store.getSkillsDir(), "qmd-memory", "SKILL.md");
+    // Create QMD memory skill template in .pi/skills/ (pi's native skill system)
+    const qmdSkillDir = join(store.getProjectRoot(), ".pi", "skills", "qmd-memory");
+    const qmdSkillPath = join(qmdSkillDir, "SKILL.md");
     try {
         await access(qmdSkillPath);
     }
     catch {
-        await mkdir(join(store.getSkillsDir(), "qmd-memory"), { recursive: true });
+        await mkdir(qmdSkillDir, { recursive: true });
         await writeFile(qmdSkillPath, QMD_SKILL_TEMPLATE, "utf-8");
     }
-    // Clean up stale QMD collections if qmd is installed
+    // Clean up stale QMD collections and initialize fresh ones if qmd is installed
     await cleanupQmdCollections(ctx.cwd);
+    await initQmdCollections(ctx.cwd);
     vibeMilestone("Initialized .vibe/ directory with 14 standard templates");
     // autoAnalyzeOnInit
     const config = await store.loadConfig();
@@ -1161,6 +1546,15 @@ async function handleInit(store, ctx) {
         }
     }
 }
+async function handleReset(store, ctx) {
+    const confirm = await ctx.ui.select("This will delete all .vibe/ contents (standards, features, config, etc.). Continue?", ["No", "Yes"]);
+    if (confirm !== "Yes") {
+        ctx.ui.notify("[Vibe] Reset cancelled", "info");
+        return;
+    }
+    await store.reset();
+    await handleInit(store, ctx);
+}
 async function handleAnalyze(store, ctx, currentModel) {
     const config = await store.loadConfig();
     const configBackup = structuredClone(config);
@@ -1180,9 +1574,12 @@ async function handleAnalyze(store, ctx, currentModel) {
     const prompt = buildAnalyzePrompt(ctx.cwd, excludePaths);
     abortHandle.currentAgent = agent;
     try {
-        await runAgent(agent, prompt, {
+        const analyzeResponse = await runAgent(agent, prompt, {
             onEvent: createAgentProgressHandler(ctx, "Analyzing", pipelineEditor, ctx.cwd),
         });
+        const analyzeUsage = aggregateUsage(agent.state.messages);
+        const analyzeLines = analyzeResponse.split("\n").length;
+        vibeAgentResponse(`Project Analyzer response (${analyzeLines} lines)`, analyzeResponse, analyzeUsage);
     }
     catch (error) {
         if (abortHandle.aborted) {
@@ -1519,16 +1916,10 @@ export const PHASE_ORDER = [
     "done",
 ];
 /**
- * Maps gate phases to their parent execution phases on resume.
- * When interrupted at a gate phase, re-execution starts from the block containing that gate.
+ * Resolves the phase to resume from. Gate phases are kept as-is so that
+ * resume skips the parent execution and goes directly to the gate prompt.
  */
 export function resolveResumePhase(phase) {
-    if (phase === "requirements_gate")
-        return "discovery";
-    if (phase === "system_design_gate")
-        return "system_architecture";
-    if (phase === "plan_gate")
-        return "planning";
     return phase;
 }
 async function handleWorkflow(store, ctx, workflowType, _requirement, options, logger, startFromPhase) {
@@ -1537,6 +1928,11 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
         await handleInit(store, ctx);
     }
     let config = await store.loadConfig();
+    // Auto-init git repository if not present
+    if (!(await isGitRepo(ctx.cwd))) {
+        await execFileAsync("git", ["init"], { cwd: ctx.cwd });
+        vibeMilestone("Initialized git repository");
+    }
     // Resolve baseBranch: config > existing orchestration state > prompt user
     if (!config.baseBranch) {
         const existingOrcState = (await store.hasOrchestrationState()) ? await store.loadOrchestrationState() : undefined;
@@ -1572,23 +1968,32 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
             vibeMilestone(`Base branch set to \`${chosenBranch}\``);
         }
     }
-    // Stale project-context warning
+    // Stale project-context check: auto-analyze if missing, warn if stale
     if (await store.isProjectContextStale(config.projectAnalysis.staleThresholdDays)) {
         const hasContext = await store.hasProjectContext();
-        const msg = hasContext
-            ? `project-context.md is older than ${config.projectAnalysis.staleThresholdDays} days. Run /vibe analyze to refresh.`
-            : "No project-context.md found. Run /vibe analyze to generate.";
-        vibeWarning(msg);
+        if (!hasContext && config.projectAnalysis.autoAnalyzeOnInit) {
+            try {
+                await handleAnalyze(store, ctx, ctx.model);
+            }
+            catch (error) {
+                vibeError(`Project analysis failed: ${error instanceof Error ? error.message : String(error)}\nRun /vibe analyze to retry.`);
+            }
+        }
+        else {
+            const msg = hasContext
+                ? `project-context.md is older than ${config.projectAnalysis.staleThresholdDays} days. Run /vibe analyze to refresh.`
+                : "No project-context.md found. Run /vibe analyze to generate.";
+            vibeWarning(msg);
+        }
     }
     const getApiKey = (provider) => ctx.modelRegistry.getApiKeyForProvider(provider);
-    const availableSkills = await buildAvailableSkillsPrompt(store);
-    const projectContext = (await store.hasProjectContext()) ? await store.readProjectContext() : undefined;
     const requestApproval = async (_step, _fId, summary) => {
+        _pi.events.emit("vibe:gate", { featureId: _fId, summary });
         // Auto-expand messages so the user can review full content before deciding
         const wasExpanded = ctx.ui.getToolsExpanded();
         if (!wasExpanded)
             ctx.ui.setToolsExpanded(true);
-        const choice = await ctx.ui.select(summary, ["Approve", "Reject", "Skip", "Abort"]);
+        const choice = await waitForGateChoice(_pi.events, ctx.ui, summary, ["Approve", "Reject", "Skip", "Abort"]);
         // Restore previous expand state after gate resolves
         if (!wasExpanded)
             ctx.ui.setToolsExpanded(false);
@@ -1604,7 +2009,8 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
             case "Abort":
                 return { passed: false, action: "abort" };
             default:
-                return { passed: false, action: "rejected" };
+                // ESC or undefined selection → pause (preserve state for resume)
+                return { passed: false, action: "pause" };
         }
     };
     /**
@@ -1620,6 +2026,9 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
         if (result.action === "abort") {
             return { proceed: false, action: "abort" };
         }
+        if (result.action === "pause") {
+            return { proceed: false, action: "pause" };
+        }
         if (result.action === "skip") {
             return { proceed: true, action: "skip" };
         }
@@ -1661,62 +2070,62 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
         let requirementsApproved = false;
         let discoveryFeedback;
         // Discovery can be skipped on resume, but must run if requirements.md is missing
-        if (!shouldRunPhase("discovery") && (await store.hasRequirements())) {
+        if (!shouldRunPhase("discovery") && !shouldRunPhase("requirements_gate") && (await store.hasRequirements())) {
             requirementsApproved = true;
         }
+        // When resuming at requirements_gate, skip discovery and go straight to gate
+        let skipDiscoveryForGate = startFromPhase === "requirements_gate" && (await store.hasRequirements());
         while (!requirementsApproved) {
-            await saveOrcState("discovery");
-            pipelineEditor.setPhase(discoveryFeedback ? "Discovery (retry)" : "Discovery");
-            const discoveryResult = await runDiscovery({
-                store,
-                config,
-                projectRoot: ctx.cwd,
-                requirement: _requirement,
-                requestUserInput: async (_questions) => {
-                    pipelineEditor.setDetail("waiting for input...");
-                    return ctx.ui.editor("Discovery: Answer the questions above");
-                },
-                getApiKey,
-                model: ctx.model,
-                onAgentEvent: createAgentProgressHandler(ctx, "Discovery", pipelineEditor, ctx.cwd),
-                onMessage: (msg) => {
-                    if (msg.includes("[REQUIREMENTS_COMPLETE]") || msg.includes("```requirements.md")) {
+            if (skipDiscoveryForGate) {
+                skipDiscoveryForGate = false;
+            }
+            else {
+                await saveOrcState("discovery");
+                pipelineEditor.setPhase(discoveryFeedback ? "Discovery (retry)" : "Discovery");
+                const discoveryResult = await runDiscovery({
+                    store,
+                    config,
+                    projectRoot: ctx.cwd,
+                    requirement: _requirement,
+                    requestUserInput: async (_questions) => {
+                        pipelineEditor.setDetail("waiting for input...");
+                        return ctx.ui.editor("Discovery: Answer the questions above");
+                    },
+                    getApiKey,
+                    model: ctx.model,
+                    onAgentEvent: createAgentProgressHandler(ctx, "Discovery", pipelineEditor, ctx.cwd),
+                    onMessage: (msg) => {
                         const lines = msg.split("\n").length;
-                        vibeAgentResponse(`Discovery complete — requirements.md (${lines} lines)`, msg);
-                    }
-                    else if (msg.includes("[QUESTIONS]")) {
-                        const questions = extractQuestions(msg);
-                        if (questions) {
-                            vibeMilestone(`Discovery: clarifying questions\n\n${questions}`);
+                        if (msg.includes("[REQUIREMENTS_COMPLETE]") || msg.includes("```requirements.md")) {
+                            vibeAgentResponse(`Discovery complete — requirements.md (${lines} lines)`, msg);
+                        }
+                        else if (msg.includes("[QUESTIONS]")) {
+                            vibeAgentResponse(`Discovery: clarifying questions (${lines} lines)`, msg);
+                        }
+                        else if (msg.startsWith("[Discovery]")) {
+                            vibeAgentResponse(`Discovery response (${lines} lines)`, msg);
                         }
                         else {
-                            vibeMilestone("Discovery: asking clarifying questions");
+                            vibeAgentResponse(`Discovery response (${lines} lines)`, msg);
                         }
-                    }
-                    else if (msg.startsWith("[Discovery]")) {
-                        vibeMilestone(msg.replace("[Discovery] ", ""));
-                    }
-                    else {
-                        const lines = msg.split("\n").length;
-                        vibeAgentResponse(`Discovery response (${lines} lines)`, msg);
-                    }
-                },
-                feedback: discoveryFeedback,
-                availableSkills,
-                onAgentCreated: (agent) => {
-                    abortHandle.currentAgent = agent;
-                },
-                onAgentFinished: () => {
-                    abortHandle.currentAgent = undefined;
-                },
-            });
-            if (!discoveryResult.completed) {
-                // Discovery cancelled: clean exit
-                vibeGate("Discovery cancelled");
-                await store.clearGlobalAgentHistoryByRole("discovery");
-                await store.clearOrchestrationState();
-                return;
-            }
+                    },
+                    feedback: discoveryFeedback,
+                    onAgentCreated: (agent) => {
+                        abortHandle.currentAgent = agent;
+                    },
+                    onAgentFinished: () => {
+                        abortHandle.currentAgent = undefined;
+                    },
+                });
+                if (discoveryResult.usage) {
+                    vibeMilestone(`Discovery tokens: ${formatTokenUsage(discoveryResult.usage)}`);
+                }
+                if (!discoveryResult.completed) {
+                    // Discovery cancelled (ESC): preserve state + agent history for resume
+                    vibeGate("Discovery paused — use `/vibe resume` to continue");
+                    return;
+                }
+            } // end: skip discovery for gate resume
             // Gate: requirements approval
             await saveOrcState("requirements_gate");
             const gateResult = await checkOrchestrationGate("requireRequirementsApproval", "[Gate] Requirements complete. Approve to proceed?");
@@ -1727,6 +2136,10 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                 await store.clearOrchestrationState();
                 return;
             }
+            if (gateResult.action === "pause") {
+                vibeGate("Paused at requirements gate — use `/vibe resume` to continue");
+                return;
+            }
             if (gateResult.action === "skip") {
                 vibeGate("Requirements review skipped");
                 requirementsApproved = true;
@@ -1741,81 +2154,83 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
             }
         }
         // ── Standards enrichment (post-Discovery) ──
-        if (!abortHandle.aborted) {
+        if (!abortHandle.aborted && shouldRunPhase("system_architecture")) {
             await runStandardsEnrichment(store, ctx, config, "discovery", abortHandle, pipelineEditor);
         }
+        if (abortHandle.aborted) {
+            vibeGate("Aborted by user (ESC)");
+            return;
+        }
         // ── Phase: System Architecture → system-design.md ──
         let systemDesignApproved = false;
         let systemDesignFeedback;
-        if (!shouldRunPhase("system_architecture") && (await store.hasSystemDesign())) {
+        if (!shouldRunPhase("system_architecture") &&
+            !shouldRunPhase("system_design_gate") &&
+            (await store.hasSystemDesign())) {
             systemDesignApproved = true;
         }
-        else if (shouldRunPhase("system_architecture") && (await store.hasSystemDesign())) {
-            // system-design.md exists — ask user if architecture update is needed
-            if (config.autonomyLevel === "full_auto") {
-                systemDesignApproved = true;
-                vibeMilestone("System design exists. Skipping architecture update (full_auto).");
+        // When system-design.md exists and phase should run, fall through to while loop (always update).
+        // System Architect handles incremental refinement automatically via "Refine and update" prompt.
+        // When resuming at system_design_gate, skip system architecture and go straight to gate
+        let skipSysArchForGate = startFromPhase === "system_design_gate" && (await store.hasSystemDesign());
+        while (!systemDesignApproved && !abortHandle.aborted) {
+            if (skipSysArchForGate) {
+                skipSysArchForGate = false;
             }
             else {
-                const choice = await ctx.ui.select("System design exists. Update architecture?", ["Skip", "Update"]);
-                if (choice === "Skip") {
-                    systemDesignApproved = true;
-                    vibeMilestone("System architecture skipped by user.");
+                await saveOrcState("system_architecture");
+                pipelineEditor.setPhase(systemDesignFeedback ? "System Architecture (retry)" : "System Architecture");
+                pipelineEditor.setDetail("");
+                // Save old content for impact analysis on re-runs
+                let oldSystemDesign;
+                if (systemDesignFeedback && (await store.hasSystemDesign())) {
+                    oldSystemDesign = await store.readSystemDesign();
                 }
-                // "Update" → falls through to while loop
-            }
-        }
-        while (!systemDesignApproved && !abortHandle.aborted) {
-            await saveOrcState("system_architecture");
-            pipelineEditor.setPhase(systemDesignFeedback ? "System Architecture (retry)" : "System Architecture");
-            pipelineEditor.setDetail("");
-            // Save old content for impact analysis on re-runs
-            let oldSystemDesign;
-            if (systemDesignFeedback && (await store.hasSystemDesign())) {
-                oldSystemDesign = await store.readSystemDesign();
-            }
-            const sysArchResult = await runSystemArchitect({
-                store,
-                config,
-                projectRoot: ctx.cwd,
-                getApiKey,
-                model: ctx.model,
-                onAgentEvent: createAgentProgressHandler(ctx, "System Architecture", pipelineEditor, ctx.cwd),
-                onMessage: (msg) => {
-                    const lines = msg.split("\n").length;
-                    vibeAgentResponse(`System design (${lines} lines)`, msg);
-                },
-                feedback: systemDesignFeedback,
-                availableSkills,
-                onAgentCreated: (agent) => {
-                    abortHandle.currentAgent = agent;
-                },
-                onAgentFinished: () => {
-                    abortHandle.currentAgent = undefined;
-                },
-            });
-            if (abortHandle.aborted) {
-                vibeGate("Aborted by user (ESC)");
-                return;
-            }
-            if (!sysArchResult.completed) {
-                vibeError("System architecture failed");
-                return;
-            }
-            // Impact analysis on re-runs (compare old vs new system-design.md)
-            if (oldSystemDesign && (await store.hasSystemDesign())) {
-                const newSystemDesign = await store.readSystemDesign();
-                const featureDesigns = await loadAllFeatureDesigns(store);
-                if (featureDesigns.size > 0) {
-                    const impact = analyzeSystemDesignImpact(oldSystemDesign, newSystemDesign, featureDesigns);
-                    if (impact.affectedFeatures.length > 0) {
-                        const lines = impact.affectedFeatures
-                            .map((f) => `- **${f.featureId}**: ${f.reasons.join("; ")}`)
-                            .join("\n");
-                        vibeWarning(`System design changes may affect ${impact.affectedFeatures.length} feature(s):\n${lines}`);
+                const sysArchResult = await runSystemArchitect({
+                    store,
+                    config,
+                    projectRoot: ctx.cwd,
+                    getApiKey,
+                    model: ctx.model,
+                    onAgentEvent: createAgentProgressHandler(ctx, "System Architecture", pipelineEditor, ctx.cwd),
+                    onMessage: (msg) => {
+                        const lines = msg.split("\n").length;
+                        vibeAgentResponse(`System design (${lines} lines)`, msg);
+                    },
+                    feedback: systemDesignFeedback,
+                    onAgentCreated: (agent) => {
+                        abortHandle.currentAgent = agent;
+                    },
+                    onAgentFinished: () => {
+                        abortHandle.currentAgent = undefined;
+                    },
+                });
+                if (sysArchResult.usage) {
+                    vibeMilestone(`System Architect tokens: ${formatTokenUsage(sysArchResult.usage)}`);
+                }
+                if (abortHandle.aborted) {
+                    vibeGate("Aborted by user (ESC)");
+                    return;
+                }
+                if (!sysArchResult.completed) {
+                    vibeError("System architecture failed");
+                    return;
+                }
+                // Impact analysis on re-runs (compare old vs new system-design.md)
+                if (oldSystemDesign && (await store.hasSystemDesign())) {
+                    const newSystemDesign = await store.readSystemDesign();
+                    const featureDesigns = await loadAllFeatureDesigns(store);
+                    if (featureDesigns.size > 0) {
+                        const impact = analyzeSystemDesignImpact(oldSystemDesign, newSystemDesign, featureDesigns);
+                        if (impact.affectedFeatures.length > 0) {
+                            const lines = impact.affectedFeatures
+                                .map((f) => `- **${f.featureId}**: ${f.reasons.join("; ")}`)
+                                .join("\n");
+                            vibeWarning(`System design changes may affect ${impact.affectedFeatures.length} feature(s):\n${lines}`);
+                        }
                     }
                 }
-            }
+            } // end: skip system architecture for gate resume
             // Gate: system design approval
             await saveOrcState("system_design_gate");
             const sysDesignGate = await checkOrchestrationGate("requireSystemDesignApproval", "[Gate] System design complete. Approve to proceed?");
@@ -1828,6 +2243,10 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                 await store.clearOrchestrationState();
                 return;
             }
+            if (sysDesignGate.action === "pause") {
+                vibeGate("Paused at system design gate — use `/vibe resume` to continue");
+                return;
+            }
             if (sysDesignGate.action === "skip") {
                 vibeGate("System design review skipped");
                 systemDesignApproved = true;
@@ -1842,20 +2261,31 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
             }
         }
         // ── Standards enrichment (post-System Architecture) ──
-        if (!abortHandle.aborted && (await store.hasSystemDesign())) {
+        if (!abortHandle.aborted && shouldRunPhase("analyze") && (await store.hasSystemDesign())) {
             await runStandardsEnrichment(store, ctx, config, "system_architect", abortHandle, pipelineEditor);
         }
+        if (abortHandle.aborted) {
+            vibeGate("Aborted by user (ESC)");
+            return;
+        }
         // ── Multi-feature orchestration path (new_feature, enhancement, refactor, auto/mixed) ──
         if (workflowType === "new_feature" ||
             workflowType === "enhancement" ||
             workflowType === "refactor" ||
             workflowType === "auto" ||
             workflowType === "mixed") {
-            // Enhancement/Refactor: run Analyze at orchestration level before Planner
-            if ((workflowType === "enhancement" || workflowType === "refactor") && shouldRunPhase("analyze")) {
+            // Run Analyze at orchestration level before Planner (all multi-feature types)
+            if ((workflowType === "new_feature" || workflowType === "enhancement" || workflowType === "refactor") &&
+                shouldRunPhase("analyze")) {
                 await saveOrcState("analyze");
                 pipelineEditor.setPhase("Analyzing");
                 pipelineEditor.setDetail("");
+                // Inject system-design.md for architectural context during impact analysis
+                let analyzerFeatureContext;
+                if (await store.hasSystemDesign()) {
+                    const sd = await store.readSystemDesign();
+                    analyzerFeatureContext = `## System Architecture\n\n${sd}`;
+                }
                 const analyzerSystemPrompt = getSystemPromptForRole("analyzer");
                 const analyzerAgent = await createRoleAgent({
                     role: "analyzer",
@@ -1864,11 +2294,14 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                     projectRoot: ctx.cwd,
                     model: ctx.model,
                     getApiKey,
-                    availableSkills,
+                    featureContext: analyzerFeatureContext,
                 });
                 abortHandle.currentAgent = analyzerAgent;
                 try {
                     const analyzerResponse = await runAgent(analyzerAgent, `Analyze the impact of the following requirements on the existing codebase. Produce an impact-report.md.\n\n${await store.readRequirements()}`, { onEvent: createAgentProgressHandler(ctx, "Analyzing", pipelineEditor, ctx.cwd) });
+                    const analyzerUsage = aggregateUsage(analyzerAgent.state.messages);
+                    const analyzerLines = analyzerResponse.split("\n").length;
+                    vibeAgentResponse(`Analyzer response (${analyzerLines} lines)`, analyzerResponse, analyzerUsage);
                     const impactContent = extractArtifactContent(analyzerResponse, "impact-report.md", true);
                     if (impactContent) {
                         await store.writeGlobalArtifact("impact-report.md", impactContent);
@@ -1895,62 +2328,69 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
             let planFeedback;
             let lastFeatureCount = 0;
             // Planning can be skipped on resume, but must run if plan.json is missing
-            if (!shouldRunPhase("planning") && (await store.hasPlan())) {
+            if (!shouldRunPhase("planning") && !shouldRunPhase("plan_gate") && (await store.hasPlan())) {
                 planApproved = true;
             }
+            // When resuming at plan_gate, skip planner and go straight to gate
+            let skipPlannerForGate = startFromPhase === "plan_gate" && (await store.hasPlan());
             while (!planApproved) {
-                // Clean up features/ from previous runs. The Planner reuses sequential
-                // featureIds (feat-001, etc.), so leftover artifacts would conflict
-                // with new orchestration. No data loss since the Planner regenerates
-                // spec.md. Ensures a clean state on Reject re-runs as well.
-                await store.clearAllFeatures();
-                await saveOrcState("planning");
-                pipelineEditor.setPhase(planFeedback ? "Planning (retry)" : "Planning");
-                pipelineEditor.setDetail("");
-                const plannerResult = await runPlanner({
-                    store,
-                    config,
-                    projectRoot: ctx.cwd,
-                    getApiKey,
-                    model: ctx.model,
-                    onAgentEvent: createAgentProgressHandler(ctx, "Planning", pipelineEditor, ctx.cwd),
-                    onMessage: (msg) => {
-                        const lines = msg.split("\n").length;
-                        if (lines > 5) {
+                if (skipPlannerForGate) {
+                    skipPlannerForGate = false;
+                }
+                else {
+                    // Clean up features/ from previous runs. The Planner reuses sequential
+                    // featureIds (feat-001, etc.), so leftover artifacts would conflict
+                    // with new orchestration. No data loss since the Planner regenerates
+                    // spec.md. Ensures a clean state on Reject re-runs as well.
+                    await store.clearAllFeatures();
+                    await saveOrcState("planning");
+                    pipelineEditor.setPhase(planFeedback ? "Planning (retry)" : "Planning");
+                    pipelineEditor.setDetail("");
+                    const plannerResult = await runPlanner({
+                        store,
+                        config,
+                        projectRoot: ctx.cwd,
+                        getApiKey,
+                        model: ctx.model,
+                        onAgentEvent: createAgentProgressHandler(ctx, "Planning", pipelineEditor, ctx.cwd),
+                        onMessage: (msg) => {
+                            const lines = msg.split("\n").length;
                             vibeAgentResponse(`Planner response (${lines} lines)`, msg);
+                        },
+                        feedback: planFeedback,
+                        onAgentCreated: (agent) => {
+                            abortHandle.currentAgent = agent;
+                        },
+                        onAgentFinished: () => {
+                            abortHandle.currentAgent = undefined;
+                        },
+                    });
+                    if (plannerResult.usage) {
+                        vibeMilestone(`Planner tokens: ${formatTokenUsage(plannerResult.usage)}`);
+                    }
+                    if (abortHandle.aborted) {
+                        vibeGate("Aborted by user (ESC)");
+                        return;
+                    }
+                    if (!plannerResult.completed) {
+                        vibeError("Planning failed");
+                        return;
+                    }
+                    lastFeatureCount = plannerResult.featureCount;
+                    // Traceability check
+                    if (await store.hasRequirements()) {
+                        const requirements = await store.readRequirements();
+                        const plan = await store.loadPlan();
+                        const unmapped = findUnmappedRequirements(requirements, plan);
+                        if (unmapped.length > 0) {
+                            vibeWarning(`Unmapped requirements: ${unmapped.join(", ")}`);
                         }
-                        else {
-                            vibeMilestone(msg);
-                        }
-                    },
-                    feedback: planFeedback,
-                    availableSkills,
-                    onAgentCreated: (agent) => {
-                        abortHandle.currentAgent = agent;
-                    },
-                    onAgentFinished: () => {
-                        abortHandle.currentAgent = undefined;
-                    },
-                });
-                if (abortHandle.aborted) {
-                    vibeGate("Aborted by user (ESC)");
-                    return;
-                }
-                if (!plannerResult.completed) {
-                    vibeError("Planning failed");
-                    return;
-                }
-                lastFeatureCount = plannerResult.featureCount;
-                // Traceability check
-                if (await store.hasRequirements()) {
-                    const requirements = await store.readRequirements();
-                    const plan = await store.loadPlan();
-                    const unmapped = findUnmappedRequirements(requirements, plan);
-                    if (unmapped.length > 0) {
-                        vibeWarning(`Unmapped requirements: ${unmapped.join(", ")}`);
                     }
-                }
+                } // end: skip planner for gate resume
                 // Gate: plan approval
+                if (lastFeatureCount === 0 && (await store.hasPlan())) {
+                    lastFeatureCount = (await store.loadPlan()).features.length;
+                }
                 await saveOrcState("plan_gate");
                 const planGateResult = await checkOrchestrationGate("requirePlanApproval", `[Gate] Plan complete (${lastFeatureCount} features). Approve to proceed to orchestration?`);
                 if (planGateResult.action === "abort") {
@@ -1965,6 +2405,10 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                     await store.clearOrchestrationState();
                     return;
                 }
+                if (planGateResult.action === "pause") {
+                    vibeGate("Paused at plan gate — use `/vibe resume` to continue");
+                    return;
+                }
                 if (planGateResult.action === "skip") {
                     vibeGate("Plan review skipped");
                     planApproved = true;
@@ -1983,9 +2427,13 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
             const plan = await store.loadPlan();
             await saveOrcState("orchestrating");
             // ── Standards enrichment (post-Planner) ──
-            if (!abortHandle.aborted) {
+            if (!abortHandle.aborted && shouldRunPhase("orchestrating")) {
                 await runStandardsEnrichment(store, ctx, config, "planner", abortHandle, pipelineEditor);
             }
+            if (abortHandle.aborted) {
+                vibeGate("Aborted by user (ESC)");
+                return;
+            }
             // Auto/Mixed mode: run Analyze after Planner if enhance-*/refactor-* features exist
             if (!abortHandle.aborted &&
                 (workflowType === "auto" || workflowType === "mixed") &&
@@ -1998,6 +2446,12 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                 if (needsAnalyze) {
                     pipelineEditor.setPhase("Analyzing");
                     pipelineEditor.setDetail("");
+                    // Inject system-design.md for architectural context during impact analysis
+                    let analyzerFeatureContext;
+                    if (await store.hasSystemDesign()) {
+                        const sd = await store.readSystemDesign();
+                        analyzerFeatureContext = `## System Architecture\n\n${sd}`;
+                    }
                     const analyzerSystemPrompt = getSystemPromptForRole("analyzer");
                     const analyzerAgent = await createRoleAgent({
                         role: "analyzer",
@@ -2006,11 +2460,14 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                         projectRoot: ctx.cwd,
                         model: ctx.model,
                         getApiKey,
-                        availableSkills,
+                        featureContext: analyzerFeatureContext,
                     });
                     abortHandle.currentAgent = analyzerAgent;
                     try {
                         const analyzerResponse = await runAgent(analyzerAgent, `Analyze the impact of the following requirements on the existing codebase. Produce an impact-report.md.\n\n${await store.readRequirements()}`, { onEvent: createAgentProgressHandler(ctx, "Analyzing", pipelineEditor, ctx.cwd) });
+                        const analyzerUsage2 = aggregateUsage(analyzerAgent.state.messages);
+                        const analyzerLines2 = analyzerResponse.split("\n").length;
+                        vibeAgentResponse(`Analyzer response (${analyzerLines2} lines)`, analyzerResponse, analyzerUsage2);
                         const impactContent = extractArtifactContent(analyzerResponse, "impact-report.md", true);
                         if (impactContent) {
                             await store.writeGlobalArtifact("impact-report.md", impactContent);
@@ -2050,8 +2507,6 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                 onAgentCreated: editorCallbacks.onAgentCreated,
                 onAgentFinished: editorCallbacks.onAgentFinished,
                 logger,
-                availableSkills,
-                projectContext,
             });
             for await (const event of orchestrationGen) {
                 // Update tool step context for chat messages
@@ -2064,6 +2519,7 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                 vibeEventToChat(ctx, event);
                 updateEditorFromEvent(event, pipelineEditor, plan.workflowType, config, options?.parentFeatureId);
                 sendStepResultMessage(event, pipelineEditor, event.data?.totalSteps ?? 0);
+                _pi.events.emit("vibe:pipeline", event);
                 // Update orchestration state on feature complete/fail/skip (runs before abort check)
                 if (event.type === "orchestration_complete" && event.data) {
                     await saveOrcState("done", {
@@ -2097,13 +2553,17 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                     break;
                 }
             }
-            // Preserve state when failed features exist to allow resume
+            // Preserve state when failed features exist or user aborted to allow resume
             const finalState = await store.loadOrchestrationState();
-            if (finalState && finalState.failedFeatures.length === 0) {
+            if (finalState && finalState.failedFeatures.length === 0 && !abortHandle.aborted) {
                 // Run Documenter only when all features succeeded
-                if (!abortHandle.aborted && finalState.completedFeatures.length > 0) {
+                if (finalState.completedFeatures.length > 0) {
                     await runDocumenter(store, ctx, config, finalState.completedFeatures, pipelineEditor, abortHandle);
                 }
+                // Update QMD index with new artifacts
+                if (!abortHandle.aborted) {
+                    await updateQmdIndex(ctx.cwd);
+                }
                 // Push baseBranch to remote after all features succeeded
                 if (!abortHandle.aborted) {
                     pipelineEditor.setDetail("pushing to remote...");
@@ -2151,13 +2611,17 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                 singleEditorCallbacks.onAgentFinished();
             },
             logger,
-            availableSkills,
-            projectContext,
         });
         abortHandle.currentRunner = runner;
         activePipelines.set(featureId, { pipeline, runner });
         pipelineEditor.setPhase(`Running: ${featureId}`);
         pipelineEditor.setSteps(pipelineStepsToInfo(pipeline));
+        // Emit feature_start so the Telegram bridge enters pipeline mode
+        _pi.events.emit("vibe:pipeline", {
+            type: "feature_start",
+            featureId,
+            data: { title: featureId, totalSteps: pipeline.steps.length },
+        });
         for await (const event of runner.run(pipeline)) {
             // Update tool step context for chat messages
             if (event.step) {
@@ -2172,6 +2636,7 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
                 pipelineEditor.setDetail(`${event.step.agent}: ${event.step.action}`);
             }
             sendStepResultMessage(event, pipelineEditor, pipeline.steps.length);
+            _pi.events.emit("vibe:pipeline", event);
             if (abortHandle.aborted) {
                 vibeGate("Aborted by user (ESC)");
                 break;
@@ -2199,6 +2664,190 @@ async function handleWorkflow(store, ctx, workflowType, _requirement, options, l
         deactivatePipelineEditor(ctx);
     }
 }
+async function handleRecover(store, ctx) {
+    // Precondition: state already exists
+    if (await store.hasOrchestrationState()) {
+        ctx.ui.notify("[Vibe] Orchestration state already exists. Use /vibe resume instead.", "warning");
+        return;
+    }
+    // Precondition: .vibe/ initialized
+    if (!(await store.isInitialized())) {
+        ctx.ui.notify("[Vibe] No .vibe/ directory found. Run /vibe init first.", "warning");
+        return;
+    }
+    // Precondition: plan.json exists
+    let planJson;
+    try {
+        const plan = await store.loadPlan();
+        planJson = JSON.stringify(plan, null, "\t");
+    }
+    catch {
+        ctx.ui.notify("[Vibe] Cannot recover without plan.json. Run a new /vibe command instead.", "error");
+        return;
+    }
+    // Gather context for the agent
+    const config = await store.loadConfig();
+    const configJson = JSON.stringify(config, null, "\t");
+    // List artifacts per feature
+    const features = await store.listFeatures();
+    const featureArtifacts = [];
+    for (const fId of features) {
+        const featureDir = store.getFeatureDir(fId);
+        try {
+            const entries = await readdir(featureDir);
+            featureArtifacts.push(`${fId}/: ${entries.join(", ")}`);
+        }
+        catch {
+            featureArtifacts.push(`${fId}/: (empty or inaccessible)`);
+        }
+    }
+    // Requirements first lines
+    let requirementSnippet = "";
+    try {
+        const reqPath = join(ctx.cwd, ".vibe", "requirements.md");
+        const reqContent = await readFile(reqPath, "utf-8");
+        requirementSnippet = reqContent.split("\n").slice(0, 5).join("\n");
+    }
+    catch {
+        requirementSnippet = "(requirements.md not found)";
+    }
+    // Git info
+    let gitInfo = "";
+    try {
+        const execFileAsync = promisify(execFile);
+        const { stdout: currentBranch } = await execFileAsync("git", ["branch", "--show-current"], { cwd: ctx.cwd });
+        const { stdout: branches } = await execFileAsync("git", ["branch", "--list"], { cwd: ctx.cwd });
+        const featureBranches = branches
+            .split("\n")
+            .map((b) => b.trim().replace("* ", ""))
+            .filter((b) => b.startsWith("feat/") || b.startsWith("fix/") || b.startsWith("enhance/") || b.startsWith("refactor/"));
+        gitInfo = `Current branch: ${currentBranch.trim()}\nFeature branches:\n${featureBranches.map((b) => `  - ${b}`).join("\n") || "  (none)"}`;
+    }
+    catch {
+        gitInfo = "(git info unavailable)";
+    }
+    const contextPrompt = `# Recovery Context
+
+## plan.json
+\`\`\`json
+${planJson}
+\`\`\`
+
+## config.json
+\`\`\`json
+${configJson}
+\`\`\`
+
+## Feature Artifacts
+${featureArtifacts.join("\n")}
+
+## Requirements (first 5 lines)
+${requirementSnippet}
+
+## Git Info
+${gitInfo}
+
+## Task
+Analyze the above context. Use your tools to read artifact contents and check git state as needed. Then propose an orchestration-state.json to restore the workflow. Output the proposed state as a single JSON code block.`;
+    // Run the recovery agent
+    const abortHandle = createAbortHandle();
+    const pipelineEditor = activatePipelineEditor(ctx, "Recovering state", abortHandle);
+    pipelineEditor.setTitle("Vibe ─ Recover");
+    pipelineEditor.setPhase("Analyzing artifacts");
+    const systemPrompt = getSystemPromptForRole("recover");
+    const agent = await createRoleAgent({
+        role: "recover",
+        systemPrompt,
+        config,
+        projectRoot: ctx.cwd,
+        model: ctx.model,
+        getApiKey: (provider) => ctx.modelRegistry.getApiKeyForProvider(provider),
+    });
+    abortHandle.currentAgent = agent;
+    let responseText;
+    try {
+        responseText = await runAgent(agent, contextPrompt, {
+            onEvent: createAgentProgressHandler(ctx, "Recovering", pipelineEditor, ctx.cwd),
+        });
+    }
+    catch (error) {
+        if (abortHandle.aborted) {
+            vibeGate("Recovery aborted by user");
+        }
+        else {
+            const msg = error instanceof Error ? error.message : String(error);
+            vibeError(`Recovery agent failed: ${msg}`);
+        }
+        ctx.ui.setStatus("vibe", undefined);
+        deactivatePipelineEditor(ctx);
+        return;
+    }
+    finally {
+        abortHandle.currentAgent = undefined;
+    }
+    if (abortHandle.aborted) {
+        vibeGate("Recovery aborted by user");
+        ctx.ui.setStatus("vibe", undefined);
+        deactivatePipelineEditor(ctx);
+        return;
+    }
+    ctx.ui.setStatus("vibe", undefined);
+    deactivatePipelineEditor(ctx);
+    // Extract JSON from response
+    const jsonStr = extractRecoverJson(responseText);
+    if (!jsonStr) {
+        ctx.ui.notify("[Vibe] Could not extract orchestration state JSON from agent response.", "error");
+        return;
+    }
+    let proposedState;
+    try {
+        proposedState = JSON.parse(jsonStr);
+    }
+    catch {
+        ctx.ui.notify("[Vibe] Agent returned invalid JSON.", "error");
+        return;
+    }
+    // Validate required fields
+    if (!proposedState.phase || !proposedState.workflowType || !Array.isArray(proposedState.completedFeatures)) {
+        ctx.ui.notify("[Vibe] Agent returned incomplete state (missing phase, workflowType, or completedFeatures).", "error");
+        return;
+    }
+    // Ensure updatedAt
+    if (!proposedState.updatedAt) {
+        proposedState.updatedAt = new Date().toISOString();
+    }
+    // Ensure arrays
+    if (!Array.isArray(proposedState.failedFeatures))
+        proposedState.failedFeatures = [];
+    if (!Array.isArray(proposedState.skippedFeatures))
+        proposedState.skippedFeatures = [];
+    // Display proposed state and ask for confirmation
+    const summary = [
+        `Workflow: ${proposedState.workflowType}`,
+        `Phase: ${proposedState.phase}`,
+        `Base branch: ${proposedState.baseBranch ?? "(not set)"}`,
+        `Completed: ${proposedState.completedFeatures.length > 0 ? proposedState.completedFeatures.join(", ") : "(none)"}`,
+        `Failed: ${proposedState.failedFeatures.length > 0 ? proposedState.failedFeatures.join(", ") : "(none)"}`,
+        `Skipped: ${proposedState.skippedFeatures.length > 0 ? proposedState.skippedFeatures.join(", ") : "(none)"}`,
+    ].join("\n");
+    const choice = await ctx.ui.select(`Proposed recovery state:\n${summary}\n\nSave and enable /vibe resume?`, [
+        "Approve",
+        "Abort",
+    ]);
+    if (choice === "Approve") {
+        await store.saveOrchestrationState(proposedState);
+        ctx.ui.notify("[Vibe] Orchestration state recovered. Use /vibe resume to continue.", "info");
+        vibeMilestone("Orchestration state recovered successfully");
+    }
+    else {
+        vibeMilestone("Recovery aborted by user");
+    }
+}
+/** Extract JSON code block from agent response text. */
+export function extractRecoverJson(text) {
+    const match = text.match(/```json\s*\n([\s\S]*?)\n```/);
+    return match ? match[1] : null;
+}
 async function handlePause(featureId, ctx) {
     const active = activePipelines.get(featureId);
     if (!active) {
@@ -2214,6 +2863,12 @@ async function handleResume(store, ctx, featureId, logger) {
     if (active) {
         const abortHandle = createAbortHandle();
         abortHandle.currentRunner = active.runner;
+        // Emit feature_start so the Telegram bridge enters pipeline mode
+        _pi.events.emit("vibe:pipeline", {
+            type: "feature_start",
+            featureId,
+            data: { totalSteps: active.pipeline.steps.length },
+        });
         const pipelineEditor = activatePipelineEditor(ctx, featureId, abortHandle);
         pipelineEditor.setTitle(`Vibe ─ Resuming`);
         pipelineEditor.setPhase(featureId);
@@ -2229,6 +2884,7 @@ async function handleResume(store, ctx, featureId, logger) {
                     pipelineEditor.setDetail(`${event.step.agent}: ${event.step.action}`);
                 }
                 sendStepResultMessage(event, pipelineEditor, active.pipeline.steps.length);
+                _pi.events.emit("vibe:pipeline", event);
                 if (abortHandle.aborted) {
                     vibeGate("Aborted by user (ESC)");
                     break;
@@ -2274,19 +2930,48 @@ async function handleResume(store, ctx, featureId, logger) {
         pipelineEditor.setPhase(persistedPhase);
         pipelineEditor.setSteps(pipelineStepsToInfo(pipeline));
         pipelineEditor.setCurrentStep(pipeline.currentStep);
+        // Emit feature_start so the Telegram bridge enters pipeline mode
+        _pi.events.emit("vibe:pipeline", {
+            type: "feature_start",
+            featureId,
+            data: { title: persistedPhase, totalSteps: pipeline.steps.length },
+        });
+        // Build requestApproval for pipeline-internal gates (merge_approve, etc.)
+        const persistedRequestApproval = async (_step, _fId, summary) => {
+            _pi.events.emit("vibe:gate", { featureId: _fId, summary });
+            const wasExpanded = ctx.ui.getToolsExpanded();
+            if (!wasExpanded)
+                ctx.ui.setToolsExpanded(true);
+            const choice = await waitForGateChoice(_pi.events, ctx.ui, summary, ["Approve", "Reject", "Skip", "Abort"]);
+            if (!wasExpanded)
+                ctx.ui.setToolsExpanded(false);
+            switch (choice) {
+                case "Approve":
+                    return { passed: true, action: "approved" };
+                case "Reject": {
+                    const feedback = await ctx.ui.input("Feedback", "Enter reason for rejection");
+                    return { passed: false, action: "feedback", feedback: feedback ?? "" };
+                }
+                case "Skip":
+                    return { passed: true, action: "skip" };
+                case "Abort":
+                    return { passed: false, action: "abort" };
+                default:
+                    return { passed: false, action: "pause" };
+            }
+        };
         const persistedToolCtx = { featureId: featureId, role: "", action: "" };
         const persistedCallbacks = createEditorAgentCallbacks(pipelineEditor, ctx.cwd, persistedAbortHandle, persistedToolCtx);
-        const resumeProjectContext = (await store.hasProjectContext()) ? await store.readProjectContext() : undefined;
         const runner = new PipelineRunner({
             store,
             config,
             projectRoot: ctx.cwd,
+            requestApproval: persistedRequestApproval,
             getApiKey,
             model: ctx.model,
             onAgentCreated: persistedCallbacks.onAgentCreated,
             onAgentFinished: persistedCallbacks.onAgentFinished,
             logger,
-            projectContext: resumeProjectContext,
         });
         persistedAbortHandle.currentRunner = runner;
         try {
@@ -2304,6 +2989,7 @@ async function handleResume(store, ctx, featureId, logger) {
                     pipelineEditor.setDetail(`${event.step.agent}: ${event.step.action}`);
                 }
                 sendStepResultMessage(event, pipelineEditor, pipeline.steps.length);
+                _pi.events.emit("vibe:pipeline", event);
                 if (persistedAbortHandle.aborted) {
                     vibeGate("Aborted by user (ESC)");
                     break;
@@ -2335,7 +3021,12 @@ async function handleResume(store, ctx, featureId, logger) {
     const orcState = await store.loadOrchestrationState();
     if (orcState) {
         vibeMilestone(`Resuming orchestration from phase: ${orcState.phase}`);
-        if (orcState.phase === "single_pipeline" && orcState.singleFeatureId) {
+        if (orcState.phase === "single_pipeline") {
+            if (!orcState.singleFeatureId) {
+                ctx.ui.notify("[Vibe] Cannot resume: single pipeline state is missing featureId. Run a new /vibe command.", "error");
+                await store.clearOrchestrationState();
+                return;
+            }
             // Single-feature path: recursive call with the featureId
             await handleResume(store, ctx, orcState.singleFeatureId, logger);
             return;
@@ -2348,7 +3039,38 @@ async function handleResume(store, ctx, featureId, logger) {
                 config = { ...config, baseBranch: orcState.baseBranch };
             }
             const getApiKey = (provider) => ctx.modelRegistry.getApiKeyForProvider(provider);
-            const plan = await store.loadPlan();
+            let plan;
+            try {
+                plan = await store.loadPlan();
+            }
+            catch {
+                ctx.ui.notify("[Vibe] Cannot resume: plan.json is missing or corrupted. Run a new /vibe command.", "error");
+                return;
+            }
+            // Build requestApproval for pipeline-internal gates (merge_approve, etc.)
+            const requestApproval = async (_step, _fId, summary) => {
+                _pi.events.emit("vibe:gate", { featureId: _fId, summary });
+                const wasExpanded = ctx.ui.getToolsExpanded();
+                if (!wasExpanded)
+                    ctx.ui.setToolsExpanded(true);
+                const choice = await waitForGateChoice(_pi.events, ctx.ui, summary, ["Approve", "Reject", "Skip", "Abort"]);
+                if (!wasExpanded)
+                    ctx.ui.setToolsExpanded(false);
+                switch (choice) {
+                    case "Approve":
+                        return { passed: true, action: "approved" };
+                    case "Reject": {
+                        const feedback = await ctx.ui.input("Feedback", "Enter reason for rejection");
+                        return { passed: false, action: "feedback", feedback: feedback ?? "" };
+                    }
+                    case "Skip":
+                        return { passed: true, action: "skip" };
+                    case "Abort":
+                        return { passed: false, action: "abort" };
+                    default:
+                        return { passed: false, action: "pause" };
+                }
+            };
             vibeMilestone(`Resuming orchestration: ${orcState.completedFeatures.length} completed, ${plan.features.length - orcState.completedFeatures.length} remaining`);
             // Reset phase to orchestrating on resume
             orcState.phase = "orchestrating";
@@ -2359,16 +3081,13 @@ async function handleResume(store, ctx, featureId, logger) {
             pipelineEditor.setTitle(`Vibe ─ ${WORKFLOW_TITLES[orcState.workflowType] ?? "Resuming"}`);
             const resumeToolCtx = { featureId: "", role: "", action: "" };
             const resumeOrcCallbacks = createEditorAgentCallbacks(pipelineEditor, ctx.cwd, resumeAbortHandle, resumeToolCtx);
-            const availableSkills = await buildAvailableSkillsPrompt(store);
-            const resumeOrcProjectContext = (await store.hasProjectContext())
-                ? await store.readProjectContext()
-                : undefined;
             try {
                 for await (const event of runOrchestration({
                     store,
                     config,
                     projectRoot: ctx.cwd,
                     plan,
+                    requestApproval,
                     getApiKey,
                     model: ctx.model,
                     parentFeatureId: orcState.options?.parentFeatureId,
@@ -2376,8 +3095,6 @@ async function handleResume(store, ctx, featureId, logger) {
                     onAgentCreated: resumeOrcCallbacks.onAgentCreated,
                     onAgentFinished: resumeOrcCallbacks.onAgentFinished,
                     logger,
-                    availableSkills,
-                    projectContext: resumeOrcProjectContext,
                 })) {
                     // Update tool step context for chat messages
                     if (event.type === "feature_start")
@@ -2389,6 +3106,7 @@ async function handleResume(store, ctx, featureId, logger) {
                     vibeEventToChat(ctx, event);
                     updateEditorFromEvent(event, pipelineEditor, plan.workflowType, config, orcState.options?.parentFeatureId);
                     sendStepResultMessage(event, pipelineEditor, event.data?.totalSteps ?? 0);
+                    _pi.events.emit("vibe:pipeline", event);
                     // Update orchestration state: overwrite with final result on orchestration_complete
                     if (event.type === "orchestration_complete" && event.data) {
                         const currentState = await store.loadOrchestrationState();
@@ -2426,13 +3144,17 @@ async function handleResume(store, ctx, featureId, logger) {
                         break;
                     }
                 }
-                // Preserve state when failed features exist to allow resume
+                // Preserve state when failed features exist or user aborted to allow resume
                 const finalState = await store.loadOrchestrationState();
-                if (finalState && finalState.failedFeatures.length === 0) {
+                if (finalState && finalState.failedFeatures.length === 0 && !resumeAbortHandle.aborted) {
                     // Run Documenter only when all features succeeded
-                    if (!resumeAbortHandle.aborted && finalState.completedFeatures.length > 0) {
+                    if (finalState.completedFeatures.length > 0) {
                         await runDocumenter(store, ctx, config, finalState.completedFeatures, pipelineEditor, resumeAbortHandle);
                     }
+                    // Update QMD index with new artifacts
+                    if (!resumeAbortHandle.aborted) {
+                        await updateQmdIndex(ctx.cwd);
+                    }
                     // Push baseBranch to remote after all features succeeded
                     if (!resumeAbortHandle.aborted) {
                         pipelineEditor.setDetail("pushing to remote...");