gsd-pi 2.59.0 → 2.60.0-dev.2580e65

package/dist/resources/extensions/gsd/tools/reopen-task.js

@@ -14,6 +14,7 @@ import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 export async function handleReopenTask(params, basePath) {
     // ── Validate required fields ────────────────────────────────────────────
     if (!params.taskId || typeof params.taskId !== "string" || params.taskId.trim() === "") {
@@ -81,7 +82,7 @@ export async function handleReopenTask(params, basePath) {
         });
     }
     catch (hookErr) {
-        process.stderr.write(`gsd: reopen-task post-mutation hook warning: ${hookErr.message}\n`);
+        logWarning("tool", `reopen-task post-mutation hook warning: ${hookErr.message}`);
     }
     return {
         milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/replan-slice.js

@@ -7,6 +7,7 @@ import { renderPlanFromDb, renderReplanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -173,7 +174,7 @@ export async function handleReplanSlice(rawParams, basePath) {
             });
         }
         catch (hookErr) {
-            process.stderr.write(`gsd: replan-slice post-mutation hook warning: ${hookErr.message}\n`);
+            logWarning("tool", `replan-slice post-mutation hook warning: ${hookErr.message}`);
         }
         return {
             milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/validate-milestone.js

@@ -15,6 +15,7 @@ import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
+import { logWarning } from "../workflow-logger.js";
 function renderValidationMarkdown(params) {
     let md = `---
 verdict: ${params.verdict}
@@ -95,7 +96,7 @@ export async function handleValidateMilestone(params, basePath) {
         await saveFile(validationPath, validationMd);
     }
     catch (renderErr) {
-        process.stderr.write(`gsd-db: validate_milestone — disk render failed, rolling back DB row: ${renderErr.message}\n`);
+        logWarning("tool", `validate_milestone — disk render failed, rolling back DB row: ${renderErr.message}`);
         deleteAssessmentByScope(params.milestoneId, 'milestone-validation');
         return { error: `disk render failed: ${renderErr.message}` };
     }

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -9,7 +9,7 @@
  *
  * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
@@ -99,6 +99,123 @@ export function executeReplan(basePath, mid, sid, capture) {
         return false;
     }
 }
+// ─── Backtrack (Milestone Regression) ────────────────────────────────────────
+/**
+ * Execute a backtrack directive — user wants to abandon current milestone
+ * and return to a previous one (milestone regression).
+ *
+ * Writes a BACKTRACK-TRIGGER.md marker at `.gsd/BACKTRACK-TRIGGER.md` with
+ * the target milestone, reason, and timestamp. The state machine (deriveState)
+ * detects this and transitions the project to the target milestone, resetting
+ * its slices to allow re-planning.
+ *
+ * Returns the extracted target milestone ID, or null if extraction failed.
+ */
+export function executeBacktrack(basePath, currentMilestoneId, capture) {
+    try {
+        // Extract target milestone from capture text or resolution.
+        // Filter out the current milestone ID to avoid picking it as the backtrack target
+        // when the text mentions both current and target milestones (e.g. "backtrack from M004 to M003").
+        const sourceText = capture.resolution ?? capture.text;
+        const allMatches = [...sourceText.matchAll(/\b(M\d{3}(?:-[a-z0-9]{6})?)\b/g)]
+            .map(m => m[1])
+            .filter(id => id !== currentMilestoneId);
+        // Reject ambiguous multi-target strings — if more than one distinct target remains,
+        // don't guess; let the user clarify.
+        const uniqueTargets = [...new Set(allMatches)];
+        const targetMilestoneId = uniqueTargets.length === 1 ? uniqueTargets[0] : null;
+        const ts = new Date().toISOString();
+        const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+        const content = [
+            `# Backtrack Trigger`,
+            ``,
+            `**Source:** Capture ${capture.id}`,
+            `**Capture:** ${capture.text}`,
+            `**Rationale:** ${capture.rationale ?? "User-initiated milestone backtrack"}`,
+            `**From:** ${currentMilestoneId}`,
+            `**Target:** ${targetMilestoneId ?? "(user to specify)"}`,
+            `**Triggered:** ${ts}`,
+            ``,
+            `Auto-mode was paused by this backtrack directive. The user directed`,
+            `that the current milestone (${currentMilestoneId}) be abandoned and work`,
+            `should return to ${targetMilestoneId ?? "a previous milestone"}.`,
+            ``,
+            `## Recovery Steps`,
+            ``,
+            `1. Review what went wrong in ${currentMilestoneId}`,
+            `2. Identify missing features/requirements from the target milestone`,
+            `3. Resume auto-mode — the state machine will re-enter discussion for the target`,
+        ].join("\n");
+        writeFileSync(triggerPath, content, "utf-8");
+        // If we have a valid target, also reset that milestone's completion status
+        // so deriveState() will re-enter it as the active milestone.
+        if (targetMilestoneId) {
+            try {
+                const targetDir = join(milestonesDir(basePath), targetMilestoneId);
+                if (existsSync(targetDir)) {
+                    // Write a regression marker so the state machine knows this milestone
+                    // needs re-discussion, not just re-execution
+                    const regressionPath = join(targetDir, `${targetMilestoneId}-REGRESSION.md`);
+                    writeFileSync(regressionPath, [
+                        `# Milestone Regression`,
+                        ``,
+                        `**From:** ${currentMilestoneId}`,
+                        `**Reason:** ${capture.text}`,
+                        `**Triggered:** ${ts}`,
+                        ``,
+                        `This milestone is being revisited because downstream milestone`,
+                        `${currentMilestoneId} failed or missed critical features that should`,
+                        `have been part of this milestone's scope.`,
+                        ``,
+                        `The discuss phase should re-evaluate requirements and identify gaps.`,
+                    ].join("\n"), "utf-8");
+                }
+            }
+            catch { /* best-effort */ }
+        }
+        return targetMilestoneId;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read the backtrack trigger file if it exists.
+ * Returns the parsed target milestone and metadata, or null.
+ */
+export function readBacktrackTrigger(basePath) {
+    const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+    if (!existsSync(triggerPath))
+        return null;
+    try {
+        const content = readFileSync(triggerPath, "utf-8");
+        const target = content.match(/\*\*Target:\*\*\s*(.+)/)?.[1]?.trim() ?? null;
+        const from = content.match(/\*\*From:\*\*\s*(.+)/)?.[1]?.trim() ?? null;
+        const capture = content.match(/\*\*Capture:\*\*\s*(.+)/)?.[1]?.trim() ?? "";
+        const triggeredAt = content.match(/\*\*Triggered:\*\*\s*(.+)/)?.[1]?.trim() ?? "";
+        return {
+            target: target === "(user to specify)" ? null : target,
+            from,
+            capture,
+            triggeredAt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Remove the backtrack trigger after it has been processed.
+ */
+export function clearBacktrackTrigger(basePath) {
+    const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+    try {
+        if (existsSync(triggerPath)) {
+            unlinkSync(triggerPath);
+        }
+    }
+    catch { /* best-effort */ }
+}
 // ─── File Overlap Detection ───────────────────────────────────────────────────
 /**
  * Detect file overlap between a capture's affected files and planned tasks.
@@ -240,6 +357,8 @@ export function executeTriageResolutions(basePath, mid, sid) {
         replanned: 0,
         deferredMilestones: 0,
         quickTasks: [],
+        stopped: 0,
+        backtracks: [],
         actions: [],
     };
     const actionable = loadActionableCaptures(basePath, mid || undefined);
@@ -318,5 +437,20 @@ export function executeTriageResolutions(basePath, mid, sid) {
             }
         }
     }
+    // Count stop/backtrack captures — these are handled by the pre-dispatch guard
+    // in runGuards(), not here. We just report them for logging purposes.
+    const allCaptures = loadAllCaptures(basePath);
+    for (const cap of allCaptures) {
+        if (cap.status !== "resolved" || cap.executed)
+            continue;
+        if (cap.classification === "stop") {
+            result.stopped++;
+            result.actions.push(`Stop directive from ${cap.id}: "${cap.text}" — will pause on next dispatch`);
+        }
+        else if (cap.classification === "backtrack") {
+            result.backtracks.push(cap);
+            result.actions.push(`Backtrack directive from ${cap.id}: "${cap.text}" — will trigger milestone regression on next dispatch`);
+        }
+    }
     return result;
 }

package/dist/resources/extensions/gsd/triage-ui.js

@@ -33,9 +33,17 @@ const CLASSIFICATION_LABELS = {
         label: "Note",
         description: "Informational only — no action needed.",
     },
+    "stop": {
+        label: "Stop",
+        description: "Halt auto-mode immediately — user directive to cease execution.",
+    },
+    "backtrack": {
+        label: "Backtrack",
+        description: "Abandon current milestone and return to a previous one.",
+    },
 };
 const ALL_CLASSIFICATIONS = [
-    "quick-task", "inject", "defer", "replan", "note",
+    "quick-task", "inject", "defer", "replan", "note", "stop", "backtrack",
 ];
 // ─── Public API ───────────────────────────────────────────────────────────────
 /**
@@ -57,8 +65,9 @@ export async function showTriageConfirmation(ctx, triageResults, captures, baseP
         const capture = captureMap.get(result.captureId);
         if (!capture)
             continue;
-        // Auto-confirm note and defer — low-impact, no plan modification
-        if (result.classification === "note" || result.classification === "defer") {
+        // Auto-confirm note, defer, stop, and backtrack — low-impact or urgent directives
+        if (result.classification === "note" || result.classification === "defer"
+            || result.classification === "stop" || result.classification === "backtrack") {
             const resolution = result.classification === "note"
                 ? "acknowledged as note"
                 : `deferred${result.targetSlice ? ` to ${result.targetSlice}` : ""}`;

package/dist/resources/extensions/gsd/workflow-events.js

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteSync } from "./atomic-write.js";
+import { logWarning } from "./workflow-logger.js";
 // ─── Session ID ───────────────────────────────────────────────────────────
 /**
  * Engine-generated session ID — stable for the lifetime of this process.
@@ -49,7 +50,7 @@ export function readEvents(logPath) {
             events.push(JSON.parse(line));
         }
         catch {
-            process.stderr.write(`workflow-events: skipping corrupted event line: ${line.slice(0, 80)}\n`);
+            logWarning("event-log", `skipping corrupted event line (${line.length} bytes)`);
         }
     }
     return events;

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -2,7 +2,9 @@
 // Centralized warning/error accumulator for the workflow engine pipeline.
 // Captures structured entries that the auto-loop can drain after each unit
 // to surface root causes for stuck loops, silent degradation, and blocked writes.
-// All entries are also persisted to .gsd/audit-log.jsonl for post-mortem analysis.
+// Error-severity entries are persisted to .gsd/audit-log.jsonl (sanitized) for
+// post-mortem analysis. Warnings are ephemeral (stderr + buffer only) to avoid
+// log amplification from expected-control-flow catch paths.
 //
 // Stderr policy: every logWarning/logError call writes immediately to stderr
 // for terminal visibility. This is intentional — unlike debug-logger (which is
@@ -177,12 +179,15 @@ function _push(severity, component, message, context) {
     if (_buffer.length > MAX_BUFFER) {
         _buffer.shift();
     }
-    // Persist to .gsd/audit-log.jsonl so entries survive context resets
-    if (_auditBasePath) {
+    // Persist errors to .gsd/audit-log.jsonl so they survive context resets.
+    // Only error-severity entries are persisted — warnings are ephemeral (stderr + buffer)
+    // to avoid log amplification from expected-control-flow catch paths.
+    if (_auditBasePath && severity === "error") {
         try {
             const auditDir = join(_auditBasePath, ".gsd");
             mkdirSync(auditDir, { recursive: true });
-            appendFileSync(join(auditDir, "audit-log.jsonl"), JSON.stringify(entry) + "\n", "utf-8");
+            const sanitized = _sanitizeForAudit(entry);
+            appendFileSync(join(auditDir, "audit-log.jsonl"), JSON.stringify(sanitized) + "\n", "utf-8");
         }
         catch (auditErr) {
             // Best-effort — never let audit write failures bubble up
@@ -190,3 +195,31 @@ function _push(severity, component, message, context) {
         }
     }
 }
+/**
+ * Sanitize a log entry before persisting to the audit JSONL file.
+ * Strips potentially sensitive context (raw paths, cwd, full error text)
+ * to avoid leaking local environment details into durable telemetry.
+ */
+function _sanitizeForAudit(entry) {
+    const sanitized = {
+        ts: entry.ts,
+        severity: entry.severity,
+        component: entry.component,
+        // Truncate message to avoid persisting oversized raw error dumps
+        message: entry.message.length > 200 ? entry.message.slice(0, 200) + "…[truncated]" : entry.message,
+    };
+    if (entry.context) {
+        // Allowlist: only persist known-safe structured keys
+        const SAFE_KEYS = new Set(["fn", "tool", "mid", "sid", "tid", "worktree"]);
+        const filtered = {};
+        for (const [k, v] of Object.entries(entry.context)) {
+            if (SAFE_KEYS.has(k)) {
+                filtered[k] = v;
+            }
+        }
+        if (Object.keys(filtered).length > 0) {
+            sanitized.context = filtered;
+        }
+    }
+    return sanitized;
+}

package/dist/resources/extensions/gsd/workflow-migration.js

@@ -6,6 +6,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { _getAdapter, transaction } from "./gsd-db.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
+import { logWarning } from "./workflow-logger.js";
 // ─── needsAutoMigration ───────────────────────────────────────────────────
 /**
  * Returns true when engine tables are empty AND a .gsd/milestones/ directory
@@ -22,8 +23,8 @@ export function needsAutoMigration(basePath) {
         if (row && row["cnt"] > 0)
             return false;
     }
-    catch {
-        // Table might not exist yet — that's fine, we can still migrate
+    catch (e) {
+        logWarning("migration", `DB probe failed: ${e.message}`);
         return false;
     }
     // Check if .gsd/milestones/ directory exists
@@ -66,7 +67,7 @@ export function migrateFromMarkdown(basePath) {
             .map(e => e.name);
     }
     catch {
-        process.stderr.write("workflow-migration: failed to read milestones directory\n");
+        logWarning("migration", "failed to read milestones directory");
         return;
     }
     if (milestoneDirs.length === 0) {
@@ -102,7 +103,7 @@ export function migrateFromMarkdown(basePath) {
                 }));
             }
             catch (err) {
-                process.stderr.write(`workflow-migration: failed to parse ROADMAP.md for ${mId}: ${err.message}\n`);
+                logWarning("migration", `failed to parse ROADMAP.md for ${mId}: ${err.message}`);
                 // Still add milestone with ID as title
                 milestoneInserts.push({ id: mId, title: mId, status: milestoneStatus });
             }
@@ -148,7 +149,7 @@ export function migrateFromMarkdown(basePath) {
                     }
                 }
                 catch (err) {
-                    process.stderr.write(`workflow-migration: failed to parse ${slice.id}-PLAN.md for ${mId}: ${err.message}\n`);
+                    logWarning("migration", `failed to parse ${slice.id}-PLAN.md for ${mId}: ${err.message}`);
                 }
             }
         }
@@ -163,8 +164,8 @@ export function migrateFromMarkdown(basePath) {
                 }
             }
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            logWarning("migration", `Orphaned summary check failed for ${mId}: ${e.message}`);
         }
     }
     // Execute all inserts atomically
@@ -245,19 +246,20 @@ export function validateMigration(basePath) {
                                 const plan = parsePlan(planContent);
                                 mdTaskCount += plan.tasks.length;
                             }
-                            catch {
-                                // Skip unreadable plan
+                            catch (e) {
+                                logWarning("migration", `Failed to read plan ${slice.id}-PLAN.md: ${e.message}`);
                             }
                         }
                     }
                 }
-                catch {
-                    // Skip unreadable roadmap
+                catch (e) {
+                    logWarning("migration", `Failed to read roadmap for ${mId}: ${e.message}`);
                 }
             }
         }
     }
-    catch {
+    catch (e) {
+        logWarning("migration", `Validation failed to read markdown: ${e.message}`);
         return { discrepancies: ["Failed to read markdown for validation"] };
     }
     // Compare counts

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -371,7 +371,7 @@ export function regenerateIfMissing(basePath, milestoneId, sliceId, fileType) {
                     regenerated++;
                 }
                 catch (err) {
-                    console.error(`[projections] regenerateIfMissing SUMMARY failed for ${task.id}:`, err);
+                    logWarning("projection", `regenerateIfMissing SUMMARY failed for ${task.id}: ${err.message}`);
                 }
             }
         }
@@ -399,7 +399,7 @@ export function regenerateIfMissing(basePath, milestoneId, sliceId, fileType) {
         return true;
     }
     catch (err) {
-        console.error(`[projections] regenerateIfMissing ${fileType} failed:`, err);
+        logWarning("projection", `regenerateIfMissing ${fileType} failed: ${err.message}`);
         return false;
     }
 }

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -375,8 +375,8 @@ function parseEventBlock(block) {
                         try {
                             params = JSON.parse(paramsMatch[1]);
                         }
-                        catch {
-                            // Keep empty params on parse error
+                        catch (e) {
+                            logWarning("reconcile", `tool call params parse failed: ${e.message}`);
                         }
                         i++; // consume params line
                     }

package/dist/resources/extensions/gsd/worktree-manager.js

@@ -51,8 +51,8 @@ export function resolveGitDir(basePath) {
             return resolve(basePath, content.slice(8));
         }
     }
-    catch {
-        // Not a file or unreadable — fall through to default
+    catch (e) {
+        logWarning("worktree", `.git file read failed: ${e.message}`);
     }
     return join(basePath, ".git");
 }
@@ -232,8 +232,9 @@ export function findNestedGitDirs(rootPath) {
         try {
             entries = readdirSync(dir);
         }
-        catch {
-            return; // Permission denied, broken symlink, etc.
+        catch (e) {
+            logWarning("worktree", `readdirSync failed: ${e.message}`);
+            return;
         }
         for (const entry of entries) {
             if (NESTED_GIT_SKIP_DIRS.has(entry))
@@ -244,7 +245,8 @@ export function findNestedGitDirs(rootPath) {
             try {
                 stat = lstatSync(fullPath);
             }
-            catch {
+            catch (e) {
+                logWarning("worktree", `lstatSync failed for ${fullPath}: ${e.message}`);
                 continue;
             }
             if (!stat.isDirectory())
@@ -261,8 +263,8 @@ export function findNestedGitDirs(rootPath) {
                     continue;
                 }
             }
-            catch {
-                // No .git here — continue scanning
+            catch (e) {
+                logWarning("worktree", `existsSync/.git check failed for ${fullPath}: ${e.message}`);
             }
             walk(fullPath, depth + 1);
         }
@@ -291,7 +293,9 @@ export function removeWorktree(basePath, name, opts = {}) {
             wtPath = entry.path;
         }
     }
-    catch { /* fall back to computed path */ }
+    catch (e) {
+        logWarning("worktree", `nativeWorktreeList parse failed: ${e.message}`);
+    }
     const resolvedWtPath = existsSync(wtPath) ? realpathSync(wtPath) : wtPath;
     // If we're inside the worktree, move out first — git can't remove an in-use directory
     const cwd = process.cwd();
@@ -305,7 +309,9 @@ export function removeWorktree(basePath, name, opts = {}) {
             try {
                 nativeBranchDelete(basePath, branch, true);
             }
-            catch { /* branch may not exist */ }
+            catch (e) {
+                logWarning("worktree", `nativeBranchDelete failed: ${e.message}`);
+            }
         }
         return;
     }
@@ -332,8 +338,8 @@ export function removeWorktree(basePath, name, opts = {}) {
                 }
             }
         }
-        catch {
-            // submodule status failed — proceed with normal removal
+        catch (e) {
+            logWarning("worktree", `submodule status check failed: ${e.message}`);
         }
     }
     // Nested .git safety (#2616): detect nested .git directories created by
@@ -360,13 +366,17 @@ export function removeWorktree(basePath, name, opts = {}) {
     try {
         nativeWorktreeRemove(basePath, resolvedWtPath, useForce);
     }
-    catch { /* may fail */ }
+    catch (e) {
+        logWarning("worktree", `nativeWorktreeRemove failed: ${e.message}`);
+    }
     // If the directory is still there (e.g. locked), try harder with force
     if (existsSync(resolvedWtPath)) {
         try {
             nativeWorktreeRemove(basePath, resolvedWtPath, true);
         }
-        catch { /* may fail */ }
+        catch (e) {
+            logWarning("worktree", `nativeWorktreeRemove (force) failed: ${e.message}`);
+        }
     }
     // (#2821) If the worktree directory STILL exists after both native removal
     // attempts (e.g. untracked files like ASSESSMENT/UAT-RESULT prevent git
@@ -393,7 +403,9 @@ export function removeWorktree(basePath, name, opts = {}) {
         try {
             nativeBranchDelete(basePath, branch, true);
         }
-        catch { /* branch may not exist */ }
+        catch (e) {
+            logWarning("worktree", `final branch delete failed: ${e.message}`);
+        }
     }
 }
 /** Paths to skip in all worktree diffs (internal/runtime artifacts). */

package/dist/resources/extensions/shared/interview-ui.js

@@ -202,7 +202,9 @@ export async function showInterviewRound(questions, opts, ctx) {
             // Auto-open the notes field when "None of the above" is selected
             // so the user can immediately provide a free-text explanation
             // instead of being trapped in a re-asking loop (bug #2715).
-            if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx)) {
+            // Only auto-open if the user hasn't already provided notes —
+            // otherwise Enter from notes mode loops back here endlessly.
+            if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx) && !states[currentIdx].notes) {
                 states[currentIdx].notesVisible = true;
                 focusNotes = true;
                 loadStateToEditor();

package/dist/resources/skills/btw/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: btw
+description: Ask a quick side question about your current work without derailing the main task. Answers from existing conversation context only — no tool calls, no file reads, single concise response. Use when you need a fast answer from what is already in this session.
+---
+
+<objective>
+Answer a quick side question using only what is already present in the current conversation context. Do not read files, run commands, search, or use any tools. Give a single, concise response and return focus to the main work.
+</objective>
+
+<behavior>
+**This is a side question, not a task.**
+
+- Answer only from information already in the conversation (files read, decisions made, code seen, context established)
+- Do NOT use any tools — no Read, no Bash, no Grep, no Search
+- If the answer requires reading something new, say so briefly and suggest the user ask as a normal prompt instead
+- Keep the response short and direct — one to a few sentences unless the question genuinely needs more
+- Do not summarize the main work, ask follow-up questions, or offer to do anything else
+- After answering, stop — do not prompt for next steps
+</behavior>
+
+<quick_start>
+Parse the argument after `/btw` as the question. Answer it directly from context.
+
+If no argument is provided, ask: "What did you want to know?"
+
+If the question cannot be answered from current context (requires reading a file, running a command, or information not yet in the session), respond with:
+"I'd need to [read X / run Y / look up Z] to answer that — ask it as a normal prompt when you're ready."
+</quick_start>
+
+<examples>
+**Good uses of /btw:**
+- `/btw what was the name of that config file again?` → answers from files already read in session
+- `/btw which branch are we on?` → answers from git context already established
+- `/btw did we already handle the null case in that function?` → answers from code already reviewed
+- `/btw what model does this use?` → answers from code or config already in context
+
+**Not a good fit for /btw (suggest normal prompt):**
+- Questions requiring reading a file not yet seen
+- Questions requiring running a command
+- Questions needing a multi-step answer or follow-up
+- Starting a new task or changing direction
+</examples>

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-DGvT_c5Vb7Wu3X-fEOVUU
+ogyMN7M-3bGGuRY08L5HR