gsd-pi 2.65.0 → 2.66.0-dev.6c91c1f

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

@@ -9,7 +9,8 @@
  *
  * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
@@ -46,11 +47,11 @@ export function executeInject(basePath, mid, sid, capture) {
         const filesSection = content.indexOf("## Files Likely Touched");
         if (filesSection !== -1) {
             const updated = content.slice(0, filesSection) + newTask + "\n\n" + content.slice(filesSection);
-            writeFileSync(planPath, updated, "utf-8");
+            atomicWriteSync(planPath, updated, "utf-8");
         }
         else {
             // No Files section — append at end
-            writeFileSync(planPath, content.trimEnd() + "\n\n" + newTask + "\n", "utf-8");
+            atomicWriteSync(planPath, content.trimEnd() + "\n\n" + newTask + "\n", "utf-8");
         }
         return newId;
     }
@@ -78,7 +79,7 @@ export function executeReplan(basePath, mid, sid, capture) {
             `This file was created by the triage pipeline. The next dispatch cycle`,
             `will detect it and enter the replanning-slice phase.`,
         ].join("\n");
-        writeFileSync(triggerPath, content, "utf-8");
+        atomicWriteSync(triggerPath, content, "utf-8");
         // Also write replan_triggered_at column for DB-backed detection
         try {
             const req = createRequire(import.meta.url);
@@ -146,7 +147,7 @@ export function executeBacktrack(basePath, currentMilestoneId, capture) {
             `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");
+        atomicWriteSync(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) {
@@ -156,7 +157,7 @@ export function executeBacktrack(basePath, currentMilestoneId, capture) {
                     // 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, [
+                    atomicWriteSync(regressionPath, [
                         `# Milestone Regression`,
                         ``,
                         `**From:** ${currentMilestoneId}`,
@@ -292,7 +293,7 @@ export function ensureDeferMilestoneDir(basePath, targetMilestone, captures) {
             captureList || `(no captures yet)`,
             ``,
         ].join("\n");
-        writeFileSync(join(msDir, `${targetMilestone}-CONTEXT-DRAFT.md`), draftContent, "utf-8");
+        atomicWriteSync(join(msDir, `${targetMilestone}-CONTEXT-DRAFT.md`), draftContent, "utf-8");
         return true;
     }
     catch {
@@ -373,13 +374,16 @@ export function executeTriageResolutions(basePath, mid, sid) {
             }
         }
     }
-    // Also process deferred captures that target milestone IDs — create
-    // milestone directories so deriveState() discovers them.
-    const deferred = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed && c.classification === "defer");
-    if (deferred.length > 0) {
-        // Group deferred captures by target milestone
+    // Also process deferred and milestone-class captures (#3542).
+    // A defer/milestone capture's "action" is the triage decision itself —
+    // once classified and resolved, the capture is done. The target milestone
+    // picks up the work naturally from its planning context.
+    const deferrable = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed &&
+        (c.classification === "defer" || c.classification === "milestone"));
+    if (deferrable.length > 0) {
+        // Group captures that reference a specific milestone — create dirs as needed.
         const byMilestone = new Map();
-        for (const cap of deferred) {
+        for (const cap of deferrable) {
             const target = cap.resolution?.match(/\b(M\d{3}(?:-[a-z0-9]{6})?)\b/)?.[1];
             if (target) {
                 const list = byMilestone.get(target) ?? [];
@@ -394,12 +398,25 @@ export function executeTriageResolutions(basePath, mid, sid) {
                 if (created) {
                     result.deferredMilestones++;
                     result.actions.push(`Created milestone ${milestoneId} for ${captures.length} deferred capture(s)`);
-                    for (const cap of captures) {
-                        markCaptureExecuted(basePath, cap.id);
-                    }
                 }
             }
         }
+        // Stamp ALL defer/milestone captures as executed (#3542 gaps 1-3).
+        // Previously only captures that triggered dir creation were stamped.
+        // Captures without a milestone ID in resolution text, or targeting an
+        // existing directory, were silently dropped — never stamped.
+        for (const cap of deferrable) {
+            if (!cap.executed) {
+                markCaptureExecuted(basePath, cap.id);
+            }
+        }
+    }
+    // Mark note captures as executed — they're informational only, no action
+    // needed. Without this they stay in "resolved but not executed" limbo (#3578).
+    const notes = loadAllCaptures(basePath).filter(c => c.status === "resolved" && !c.executed && c.classification === "note");
+    for (const cap of notes) {
+        markCaptureExecuted(basePath, cap.id);
+        result.actions.push(`Note acknowledged: ${cap.id} — "${cap.text}"`);
     }
     if (actionable.length === 0)
         return result;

package/dist/resources/extensions/gsd/undo.js

@@ -2,9 +2,10 @@
 // handleUndo: Rollback the most recent completed unit (revert git, remove state, uncheck plans).
 // handleUndoTask: Reset a single task's DB status to "pending" and re-render markdown.
 // handleResetSlice: Reset a slice and all its tasks, re-rendering plan + roadmap.
-import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, unlinkSync, readdirSync } from "node:fs";
 import { join, basename } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
+import { atomicWriteSync } from "./atomic-write.js";
 import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
@@ -331,7 +332,7 @@ export function uncheckTaskInPlan(basePath, mid, sid, tid) {
     const regex = new RegExp(`^(\\s*-\\s*)\\[x\\](\\s*\\**${tid}\\**[:\\s])`, "mi");
     if (regex.test(content)) {
         content = content.replace(regex, "$1[ ]$2");
-        writeFileSync(planFile, content, "utf-8");
+        atomicWriteSync(planFile, content);
         return true;
     }
     return false;

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

@@ -24,6 +24,7 @@ export function appendEvent(basePath, event) {
         .digest("hex")
         .slice(0, 16);
     const fullEvent = {
+        v: 2,
         ...event,
         hash,
         session_id: ENGINE_SESSION_ID,

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

@@ -223,7 +223,7 @@ function _sanitizeForAudit(entry) {
     };
     if (entry.context) {
         // Allowlist: only persist known-safe structured keys
-        const SAFE_KEYS = new Set(["fn", "tool", "mid", "sid", "tid", "worktree"]);
+        const SAFE_KEYS = new Set(["fn", "tool", "mid", "sid", "tid", "worktree", "id", "error", "count"]);
         const filtered = {};
         for (const [k, v] of Object.entries(entry.context)) {
             if (SAFE_KEYS.has(k)) {

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

@@ -6,6 +6,7 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { logWarning } from "./workflow-logger.js";
+import { isClosedStatus } from "./status-guards.js";
 import { deriveState } from "./state.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────
 /**
@@ -38,7 +39,7 @@ export function renderPlanContent(sliceRow, taskRows) {
     lines.push("");
     lines.push("## Tasks");
     for (const task of taskRows) {
-        const checkbox = task.status === "done" || task.status === "complete" ? "[x]" : "[ ]";
+        const checkbox = isClosedStatus(task.status) ? "[x]" : "[ ]";
         lines.push(`- ${checkbox} **${task.id}: ${task.title}** \u2014 ${task.description}`);
         // Estimate subline (always present if non-empty)
         if (task.estimate) {
@@ -96,7 +97,7 @@ export function renderRoadmapContent(milestoneRow, sliceRows) {
     lines.push("| ID | Slice | Risk | Depends | Done | After this |");
     lines.push("|----|-------|------|---------|------|------------|");
     for (const slice of sliceRows) {
-        const done = slice.status === "done" || slice.status === "complete" ? "\u2705" : "\u2B1C";
+        const done = isClosedStatus(slice.status) ? "\u2705" : "\u2B1C";
         // depends is already parsed to string[] by rowToSlice
         let depends = "\u2014";
         if (slice.depends && slice.depends.length > 0) {
@@ -324,13 +325,10 @@ export async function renderAllProjections(basePath, milestoneId) {
     // Query all slices for this milestone
     const sliceRows = getMilestoneSlices(milestoneId);
     for (const slice of sliceRows) {
-        // Render PLAN.md for each slice
-        try {
-            renderPlanProjection(basePath, milestoneId, slice.id);
-        }
-        catch (err) {
-            logWarning("projection", `renderPlanProjection failed for ${milestoneId}/${slice.id}: ${err.message}`);
-        }
+        // PLAN.md is rendered by the authoritative markdown-renderer.js in
+        // plan-slice/replan-slice tools. Do NOT overwrite it here — the simplified
+        // projection is missing key sections (Must-Haves, Verification, Files
+        // Likely Touched) and corrupts multi-line task descriptions (#3651).
         // Render SUMMARY.md for each completed task
         const taskRows = getSliceTasks(milestoneId, slice.id);
         const doneTasks = taskRows.filter(t => t.status === "done" || t.status === "complete");

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

@@ -2,8 +2,11 @@ import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { readEvents, findForkPoint, appendEvent, getSessionId } from "./workflow-events.js";
-import { transaction, updateTaskStatus, updateSliceStatus, getSliceTasks, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.js";
+import { transaction, updateTaskStatus, updateSliceStatus, updateMilestoneStatus, getSliceTasks, insertMilestone, _getAdapter, getMilestoneSlices, insertVerificationEvidence, upsertDecision, openDatabase, setTaskBlockerDiscovered, } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
+import { invalidateStateCache } from "./state.js";
+import { clearPathCache } from "./paths.js";
+import { clearParseCache } from "./files.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { acquireSyncLock, releaseSyncLock } from "./sync-lock.js";
@@ -44,7 +47,15 @@ function replayEvents(events) {
     transaction(() => {
         for (const event of events) {
             const p = event.params;
-            switch (event.cmd) {
+            // Normalize cmd format: completion tools write hyphens ("complete-task"),
+            // legacy logs use underscores ("complete_task"). Accept both formats.
+            // Type guard: malformed event lines with non-string cmd are skipped.
+            if (typeof event.cmd !== "string") {
+                logWarning("reconcile", `Event with non-string cmd skipped: ${JSON.stringify(event.cmd)}`);
+                continue;
+            }
+            const cmd = event.cmd.replace(/-/g, "_");
+            switch (cmd) {
                 case "complete_task": {
                     const milestoneId = p["milestoneId"];
                     const sliceId = p["sliceId"];
@@ -60,13 +71,11 @@ function replayEvents(events) {
                     break;
                 }
                 case "report_blocker": {
-                    // report_blocker marks the task with blocker_discovered = 1
-                    // The DB helper updateTaskStatus doesn't handle blockers,
-                    // so we just update status to "blocked" as a best-effort replay.
                     const milestoneId = p["milestoneId"];
                     const sliceId = p["sliceId"];
                     const taskId = p["taskId"];
                     updateTaskStatus(milestoneId, sliceId, taskId, "blocked");
+                    setTaskBlockerDiscovered(milestoneId, sliceId, taskId, true);
                     break;
                 }
                 case "record_verification": {
@@ -91,9 +100,64 @@ function replayEvents(events) {
                     replaySliceComplete(milestoneId, sliceId, event.ts);
                     break;
                 }
+                case "complete_milestone": {
+                    const milestoneId = p["milestoneId"];
+                    if (!milestoneId)
+                        break;
+                    // Invariant check: only mark complete if all slices are closed.
+                    // Without this guard, a reordered/partial event stream could close
+                    // a milestone while work is still incomplete.
+                    const mSlices = getMilestoneSlices(milestoneId);
+                    const allClosed = mSlices.length === 0 || mSlices.every(s => isClosedStatus(s.status));
+                    if (allClosed) {
+                        updateMilestoneStatus(milestoneId, "complete", event.ts);
+                    }
+                    else {
+                        logWarning("reconcile", `Skipping complete_milestone replay for ${milestoneId}: not all slices are closed`);
+                    }
+                    break;
+                }
+                case "plan_milestone": {
+                    // Replay milestone creation — uses INSERT OR IGNORE (gsd-db's insertMilestone is safe)
+                    const mId = p["milestoneId"];
+                    if (mId) {
+                        insertMilestone({ id: mId, title: p["title"] ?? mId });
+                    }
+                    break;
+                }
                 case "plan_slice": {
-                    // plan_slice events are informational — slice should already exist.
-                    // No DB mutation needed during replay (the slice was inserted at plan time).
+                    // Replay slice creation — strict INSERT OR IGNORE to avoid overwriting
+                    // progressed status. insertSlice() uses ON CONFLICT DO UPDATE which
+                    // could downgrade a completed slice back to pending.
+                    const milestoneId = p["milestoneId"];
+                    const sliceId = p["sliceId"];
+                    if (milestoneId && sliceId) {
+                        const adapter = _getAdapter();
+                        if (adapter) {
+                            adapter.prepare(`INSERT OR IGNORE INTO slices (milestone_id, id, title, status, created_at)
+               VALUES (:mid, :sid, :title, 'pending', :ts)`).run({ ":mid": milestoneId, ":sid": sliceId, ":title": p["title"] ?? sliceId, ":ts": event.ts });
+                        }
+                    }
+                    break;
+                }
+                case "plan_task": {
+                    // Replay task creation — strict INSERT OR IGNORE to avoid overwriting
+                    // progressed status. insertTask() uses ON CONFLICT DO UPDATE which
+                    // could downgrade a done/in-progress task back to pending.
+                    const milestoneId = p["milestoneId"];
+                    const sliceId = p["sliceId"];
+                    const taskId = p["taskId"];
+                    if (milestoneId && sliceId && taskId) {
+                        const adapter = _getAdapter();
+                        if (adapter) {
+                            adapter.prepare(`INSERT OR IGNORE INTO tasks (milestone_id, slice_id, id, title, status, created_at)
+               VALUES (:mid, :sid, :tid, :title, 'pending', :ts)`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId, ":title": p["title"] ?? taskId, ":ts": event.ts });
+                        }
+                    }
+                    break;
+                }
+                case "replan_slice": {
+                    // Informational — replan events don't mutate DB during replay
                     break;
                 }
                 case "save_decision": {
@@ -111,7 +175,7 @@ function replayEvents(events) {
                     break;
                 }
                 default:
-                    // Unknown commands are silently skipped during replay
+                    logWarning("reconcile", `Unknown event cmd during replay: "${event.cmd}" — skipped`);
                     break;
             }
         }
@@ -125,22 +189,37 @@ function replayEvents(events) {
  */
 export function extractEntityKey(event) {
     const p = event.params;
-    switch (event.cmd) {
+    // Normalize cmd format: accept both hyphens and underscores
+    if (typeof event.cmd !== "string")
+        return null;
+    const cmd = event.cmd.replace(/-/g, "_");
+    switch (cmd) {
         case "complete_task":
         case "start_task":
         case "report_blocker":
         case "record_verification":
+        case "plan_task":
             return typeof p["taskId"] === "string"
                 ? { type: "task", id: p["taskId"] }
                 : null;
         case "complete_slice":
+        case "replan_slice":
             return typeof p["sliceId"] === "string"
                 ? { type: "slice", id: p["sliceId"] }
                 : null;
+        case "complete_milestone":
+            return typeof p["milestoneId"] === "string"
+                ? { type: "milestone", id: p["milestoneId"] }
+                : null;
         case "plan_slice":
             return typeof p["sliceId"] === "string"
                 ? { type: "slice_plan", id: p["sliceId"] }
                 : null;
+        case "complete_milestone":
+        case "plan_milestone":
+            return typeof p["milestoneId"] === "string"
+                ? { type: "milestone", id: p["milestoneId"] }
+                : null;
         case "save_decision":
             if (typeof p["scope"] === "string" && typeof p["decision"] === "string") {
                 return { type: "decision", id: `${p["scope"]}:${p["decision"]}` };
@@ -291,6 +370,13 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     indexed.sort((a, b) => a.e.ts.localeCompare(b.e.ts) || a.i - b.i);
     const merged = indexed.map(({ e }) => e);
     // Step 7: Write merged event log FIRST (so crash recovery can re-derive DB state)
+    // Guard: detect concurrent appendEvent calls between our read (step 1) and
+    // this rewrite. If the log grew, re-read and retry to avoid dropping events.
+    const preWriteEvents = readEvents(mainLogPath);
+    if (preWriteEvents.length > mainEvents.length) {
+        logWarning("reconcile", `Event log grew during reconcile (${mainEvents.length} → ${preWriteEvents.length}), retrying with fresh read`);
+        return _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath);
+    }
     const baseEvents = mainEvents.slice(0, forkPoint + 1);
     const mergedLog = baseEvents.concat(merged);
     const logContent = mergedLog.map((e) => JSON.stringify(e)).join("\n") + (mergedLog.length > 0 ? "\n" : "");
@@ -306,6 +392,11 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     catch (err) {
         logWarning("reconcile", "manifest write failed (non-fatal)", { error: err.message });
     }
+    // Step 10: Invalidate caches so deriveState() sees post-reconcile DB state.
+    // Use targeted invalidation (not invalidateAllCaches) to avoid wiping artifacts table.
+    invalidateStateCache();
+    clearPathCache();
+    clearParseCache();
     return { autoMerged: merged.length, conflicts: [] };
 }
 // ─── Conflict Resolution (D-06) ─────────────────────────────────────────────

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

@@ -29,8 +29,17 @@ let cachedRegistry = null;
 export function loadRegistry() {
     if (cachedRegistry)
         return cachedRegistry;
-    const content = readFileSync(registryPath, "utf-8");
-    cachedRegistry = JSON.parse(content);
+    if (!existsSync(registryPath)) {
+        cachedRegistry = { version: 1, templates: {} };
+        return cachedRegistry;
+    }
+    try {
+        const content = readFileSync(registryPath, "utf-8");
+        cachedRegistry = JSON.parse(content);
+    }
+    catch {
+        cachedRegistry = { version: 1, templates: {} };
+    }
     return cachedRegistry;
 }
 /**

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

@@ -44,7 +44,10 @@ function normalizePathForComparison(path) {
 export function resolveGitDir(basePath) {
     const gitPath = join(basePath, ".git");
     if (!existsSync(gitPath))
-        return join(basePath, ".git");
+        return gitPath;
+    // In a normal repo .git is a directory — skip the file read (#3597)
+    if (lstatSync(gitPath).isDirectory())
+        return gitPath;
     try {
         const content = readFileSync(gitPath, "utf-8").trim();
         if (content.startsWith("gitdir: ")) {
@@ -54,7 +57,7 @@ export function resolveGitDir(basePath) {
     catch (e) {
         logWarning("worktree", `.git file read failed: ${e.message}`);
     }
-    return join(basePath, ".git");
+    return gitPath;
 }
 export function worktreesDir(basePath) {
     return join(basePath, ".gsd", "worktrees");

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

@@ -34,6 +34,15 @@ function getService(basePath) {
     }
     return cachedService;
 }
+/**
+ * Clear the cached GitServiceImpl. For testing only — forces the next
+ * getService() call to re-read preferences and create a fresh instance.
+ * @internal
+ */
+export function _resetServiceCache() {
+    cachedService = null;
+    cachedBasePath = null;
+}
 /**
  * Set the active milestone ID on the cached GitServiceImpl.
  * This enables integration branch resolution in getMainBranch().

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

@@ -204,7 +204,7 @@ export async function showInterviewRound(questions, opts, ctx) {
             // instead of being trapped in a re-asking loop (bug #2715).
             // 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) {
+            if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx) && !states[currentIdx].notes && !states[currentIdx].notesVisible) {
                 states[currentIdx].notesVisible = true;
                 focusNotes = true;
                 loadStateToEditor();

package/dist/resources/extensions/subagent/agents.js

@@ -5,6 +5,23 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
 const PROJECT_AGENT_DIR_CANDIDATES = [".gsd", ".pi"];
+function parseAgentTools(value) {
+    if (typeof value === "string") {
+        const tools = value
+            .split(",")
+            .map((tool) => tool.trim())
+            .filter(Boolean);
+        return tools.length > 0 ? tools : undefined;
+    }
+    if (Array.isArray(value)) {
+        const tools = value
+            .flatMap((tool) => typeof tool === "string" ? tool.split(",") : [])
+            .map((tool) => tool.trim())
+            .filter(Boolean);
+        return tools.length > 0 ? tools : undefined;
+    }
+    return undefined;
+}
 function loadAgentsFromDir(dir, source) {
     const agents = [];
     if (!fs.existsSync(dir)) {
@@ -31,13 +48,10 @@ function loadAgentsFromDir(dir, source) {
             continue;
         }
         const { frontmatter, body } = parseFrontmatter(content);
-        if (!frontmatter.name || !frontmatter.description) {
+        if (typeof frontmatter.name !== "string" || typeof frontmatter.description !== "string") {
             continue;
         }
-        const tools = frontmatter.tools
-            ?.split(",")
-            .map((t) => t.trim())
-            .filter(Boolean);
+        const tools = parseAgentTools(frontmatter.tools);
         agents.push({
             name: frontmatter.name,
             description: frontmatter.description,

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

@@ -1 +1 @@
-MRM3OSYIAa4HMDqVGQ9nt
+_X1i-S7l1jZfb7lmIZozb

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -11,37 +11,37 @@
   "/api/captures/route": "/api/captures",
   "/api/export-data/route": "/api/export-data",
   "/api/browse-directories/route": "/api/browse-directories",
-  "/api/forensics/route": "/api/forensics",
   "/api/git/route": "/api/git",
+  "/api/forensics/route": "/api/forensics",
   "/api/history/route": "/api/history",
   "/api/hooks/route": "/api/hooks",
-  "/api/inspect/route": "/api/inspect",
   "/api/knowledge/route": "/api/knowledge",
   "/api/experimental/route": "/api/experimental",
+  "/api/inspect/route": "/api/inspect",
   "/api/live-state/route": "/api/live-state",
   "/api/notifications/route": "/api/notifications",
-  "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
-  "/api/onboarding/route": "/api/onboarding",
-  "/api/projects/route": "/api/projects",
+  "/api/preferences/route": "/api/preferences",
   "/api/session/browser/route": "/api/session/browser",
+  "/api/onboarding/route": "/api/onboarding",
+  "/api/session/command/route": "/api/session/command",
   "/api/session/events/route": "/api/session/events",
-  "/api/session/manage/route": "/api/session/manage",
   "/api/settings-data/route": "/api/settings-data",
-  "/api/session/command/route": "/api/session/command",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/shutdown/route": "/api/shutdown",
   "/api/skill-health/route": "/api/skill-health",
   "/api/steer/route": "/api/steer",
   "/api/terminal/input/route": "/api/terminal/input",
-  "/api/files/route": "/api/files",
   "/api/terminal/resize/route": "/api/terminal/resize",
   "/api/switch-root/route": "/api/switch-root",
+  "/api/files/route": "/api/files",
   "/api/terminal/sessions/route": "/api/terminal/sessions",
-  "/api/terminal/upload/route": "/api/terminal/upload",
-  "/api/terminal/stream/route": "/api/terminal/stream",
-  "/api/undo/route": "/api/undo",
   "/api/visualizer/route": "/api/visualizer",
+  "/api/terminal/upload/route": "/api/terminal/upload",
+  "/api/projects/route": "/api/projects",
   "/api/update/route": "/api/update",
+  "/api/terminal/stream/route": "/api/terminal/stream",
   "/api/remote-questions/route": "/api/remote-questions",
+  "/api/undo/route": "/api/undo",
   "/page": "/"
 }

package/dist/web/standalone/.next/build-manifest.json

@@ -4,14 +4,14 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/MRM3OSYIAa4HMDqVGQ9nt/_buildManifest.js",
-    "static/MRM3OSYIAa4HMDqVGQ9nt/_ssgManifest.js"
+    "static/_X1i-S7l1jZfb7lmIZozb/_buildManifest.js",
+    "static/_X1i-S7l1jZfb7lmIZozb/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/webpack-a1c1e452c6b32d04.js",
+    "static/chunks/webpack-9fed74684e1c5bb1.js",
     "static/chunks/4bd1b696-e5d7c65570c947b7.js",
     "static/chunks/3794-337d1ca25ad99a89.js",
-    "static/chunks/main-app-d3d4c336195465f9.js"
+    "static/chunks/main-app-fdab67f7802d7832.js"
   ],
   "rootMainFilesTree": {},
   "pages": {

package/dist/web/standalone/.next/prerender-manifest.json

@@ -78,8 +78,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "bb1a193e6c1bf4abd4a9d63cdf8655b7",
-    "previewModeSigningKey": "ca5e2b71c749274a2c0a666756ffb23c45fc42b15d3d6d88453fff2c7153813c",
-    "previewModeEncryptionKey": "8ab4799711ced11dba484f001c1fb80246ebf723c020e899c9dbccc68dbde139"
+    "previewModeId": "c7bdd50bc7b86c00e028499fa79f4347",
+    "previewModeSigningKey": "80ca15367c0ce4e9c5beeb9c9f454f2076f15265b876af88f0ee89d880ea8215",
+    "previewModeEncryptionKey": "d162efa9d90ba18d616511e57429f642af2c6ba6231df509da0e2cc144d49b1e"
   }
 }

package/dist/web/standalone/.next/react-loadable-manifest.json

@@ -6,7 +6,7 @@
       "static/chunks/363642f4.f9053a63f1b97508.js",
       "static/chunks/4986-c2fc8845ce785303.js",
       "static/chunks/2008.817d0885545aaea9.js",
-      "static/chunks/6502.7593d7797a4b3999.js"
+      "static/chunks/6502.8874bcae249c02e1.js"
     ]
   },
   "components/gsd/chat-mode.tsx -> react-markdown": {

package/dist/web/standalone/.next/required-server-files.json

@@ -100,7 +100,7 @@
         "transform": "lodash/{{member}}"
       }
     },
-    "outputFileTracingRoot": "/home/runner/_work/gsd-2/gsd-2",
+    "outputFileTracingRoot": "/__w/gsd-2/gsd-2",
     "cacheComponents": false,
     "cacheLife": {
       "default": {
@@ -297,11 +297,11 @@
       "node-pty"
     ],
     "turbopack": {
-      "root": "/home/runner/_work/gsd-2/gsd-2"
+      "root": "/__w/gsd-2/gsd-2"
     },
     "distDirRoot": ".next"
   },
-  "appDir": "/home/runner/_work/gsd-2/gsd-2/web",
+  "appDir": "/__w/gsd-2/gsd-2/web",
   "relativeAppDir": "web",
   "files": [
     ".next/routes-manifest.json",