gsd-pi 2.52.0 → 2.53.0-dev.a67436f

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

@@ -9,6 +9,7 @@ import { join } from "node:path";
 import { mkdirSync } from "node:fs";
 import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, updateMilestoneStatus, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
+import { isClosedStatus } from "../status-guards.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -89,7 +90,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `milestone not found: ${params.milestoneId}`;
             return;
         }
-        if (milestone.status === "complete" || milestone.status === "done") {
+        if (isClosedStatus(milestone.status)) {
             guardError = `milestone ${params.milestoneId} is already complete`;
             return;
         }
@@ -99,7 +100,7 @@ export async function handleCompleteMilestone(params, basePath) {
             guardError = `no slices found for milestone ${params.milestoneId}`;
             return;
         }
-        const incompleteSlices = slices.filter(s => s.status !== "complete" && s.status !== "done");
+        const incompleteSlices = slices.filter(s => !isClosedStatus(s.status));
         if (incompleteSlices.length > 0) {
             const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
             guardError = `incomplete slices: ${incompleteIds}`;
@@ -108,7 +109,7 @@ export async function handleCompleteMilestone(params, basePath) {
         // Deep check: verify all tasks in all slices are complete
         for (const slice of slices) {
             const tasks = getSliceTasks(params.milestoneId, slice.id);
-            const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+            const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
             if (incompleteTasks.length > 0) {
                 const ids = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
                 guardError = `slice ${slice.id} has incomplete tasks: ${ids}`;

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

@@ -8,6 +8,7 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
+import { isClosedStatus } from "../status-guards.js";
 import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, setSliceSummaryMd, } from "../gsd-db.js";
 import { resolveSlicePath, clearPathCache } from "../paths.js";
 import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
@@ -179,12 +180,12 @@ export async function handleCompleteSlice(params, basePath) {
         // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
         // Only block if they exist and are closed.
         const milestone = getMilestone(params.milestoneId);
-        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+        if (milestone && isClosedStatus(milestone.status)) {
             guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
-        if (slice && (slice.status === "complete" || slice.status === "done")) {
+        if (slice && isClosedStatus(slice.status)) {
             guardError = `slice ${params.sliceId} is already complete — use gsd_slice_reopen first if you need to redo it`;
             return;
         }
@@ -194,7 +195,7 @@ export async function handleCompleteSlice(params, basePath) {
             guardError = `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}`;
             return;
         }
-        const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+        const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
         if (incompleteTasks.length > 0) {
             const incompleteIds = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
             guardError = `incomplete tasks: ${incompleteIds}`;

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

@@ -8,6 +8,7 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
+import { isClosedStatus } from "../status-guards.js";
 import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, setTaskSummaryMd, deleteVerificationEvidence, } from "../gsd-db.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
 import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
@@ -122,17 +123,17 @@ export async function handleCompleteTask(params, basePath) {
         // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
         // Only block if they exist and are closed.
         const milestone = getMilestone(params.milestoneId);
-        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+        if (milestone && isClosedStatus(milestone.status)) {
             guardError = `cannot complete task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
-        if (slice && (slice.status === "complete" || slice.status === "done")) {
+        if (slice && isClosedStatus(slice.status)) {
             guardError = `cannot complete task in a closed slice: ${params.sliceId} (status: ${slice.status})`;
             return;
         }
         const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
-        if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
+        if (existingTask && isClosedStatus(existingTask.status)) {
             guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
             return;
         }

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

@@ -1,22 +1,12 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
 import { transaction, getMilestone, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function validateStringArray(value, field) {
-    if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array`);
-    }
-    if (value.some((item) => !isNonEmptyString(item))) {
-        throw new Error(`${field} must contain only non-empty strings`);
-    }
-    return value;
-}
 function validateRiskEntries(value) {
     if (!Array.isArray(value)) {
         throw new Error("keyRisks must be an array");
@@ -152,7 +142,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
     try {
         transaction(() => {
             const existingMilestone = getMilestone(params.milestoneId);
-            if (existingMilestone && (existingMilestone.status === "complete" || existingMilestone.status === "done")) {
+            if (existingMilestone && isClosedStatus(existingMilestone.status)) {
                 guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
                 return;
             }
@@ -164,7 +154,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
                         guardError = `depends_on references unknown milestone: ${depId}`;
                         return;
                     }
-                    if (dep.status !== "complete" && dep.status !== "done") {
+                    if (!isClosedStatus(dep.status)) {
                         guardError = `depends_on milestone ${depId} is not yet complete (status: ${dep.status})`;
                         return;
                     }

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

@@ -1,22 +1,12 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString } from "../validation.js";
 import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function validateStringArray(value, field) {
-    if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array`);
-    }
-    if (value.some((item) => !isNonEmptyString(item))) {
-        throw new Error(`${field} must contain only non-empty strings`);
-    }
-    return value;
-}
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -113,7 +103,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `milestone not found: ${params.milestoneId}`;
                 return;
             }
-            if (parentMilestone.status === "complete" || parentMilestone.status === "done") {
+            if (isClosedStatus(parentMilestone.status)) {
                 guardError = `cannot plan slice in a closed milestone: ${params.milestoneId} (status: ${parentMilestone.status})`;
                 return;
             }
@@ -122,7 +112,7 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
                 return;
             }
-            if (parentSlice.status === "complete" || parentSlice.status === "done") {
+            if (isClosedStatus(parentSlice.status)) {
                 guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
                 return;
             }

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

@@ -1,22 +1,12 @@
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
 import { transaction, getSlice, getTask, insertTask, upsertTaskPlanning } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderTaskPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
-function validateStringArray(value, field) {
-    if (!Array.isArray(value)) {
-        throw new Error(`${field} must be an array`);
-    }
-    if (value.some((item) => !isNonEmptyString(item))) {
-        throw new Error(`${field} must contain only non-empty strings`);
-    }
-    return value;
-}
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -61,12 +51,12 @@ export async function handlePlanTask(rawParams, basePath) {
                 guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
                 return;
             }
-            if (parentSlice.status === "complete" || parentSlice.status === "done") {
+            if (isClosedStatus(parentSlice.status)) {
                 guardError = `cannot plan task in a closed slice: ${params.sliceId} (status: ${parentSlice.status})`;
                 return;
             }
             const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
-            if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
+            if (existingTask && isClosedStatus(existingTask.status)) {
                 guardError = `cannot re-plan task ${params.taskId}: it is already complete — use gsd_task_reopen first`;
                 return;
             }

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -1,14 +1,13 @@
+import { join } from "node:path";
 import { clearParseCache } from "../files.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString } from "../validation.js";
 import { transaction, getMilestone, getMilestoneSlices, getSlice, insertSlice, updateSliceFields, insertAssessment, deleteSlice, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-import { join } from "node:path";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -76,7 +75,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                 guardError = `milestone not found: ${params.milestoneId}`;
                 return;
             }
-            if (milestone.status === "complete" || milestone.status === "done") {
+            if (isClosedStatus(milestone.status)) {
                 guardError = `cannot reassess a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
                 return;
             }
@@ -86,7 +85,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                 guardError = `completedSliceId not found: ${params.milestoneId}/${params.completedSliceId}`;
                 return;
             }
-            if (completedSlice.status !== "complete" && completedSlice.status !== "done") {
+            if (!isClosedStatus(completedSlice.status)) {
                 guardError = `completedSliceId ${params.completedSliceId} is not complete (status: ${completedSlice.status}) — reassess can only be called after a slice finishes`;
                 return;
             }
@@ -94,7 +93,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             const existingSlices = getMilestoneSlices(params.milestoneId);
             const completedSliceIds = new Set();
             for (const slice of existingSlices) {
-                if (slice.status === "complete" || slice.status === "done") {
+                if (isClosedStatus(slice.status)) {
                     completedSliceIds.add(slice.id);
                 }
             }

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

@@ -11,6 +11,7 @@
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { getMilestone, getSlice, getSliceTasks, updateSliceStatus, updateTaskStatus, transaction, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -31,8 +32,8 @@ export async function handleReopenSlice(params, basePath) {
             guardError = `milestone not found: ${params.milestoneId}`;
             return;
         }
-        if (milestone.status === "complete" || milestone.status === "done") {
-            guardError = `cannot reopen slice inside a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+        if (isClosedStatus(milestone.status)) {
+            guardError = `cannot reopen slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
         const slice = getSlice(params.milestoneId, params.sliceId);
@@ -40,7 +41,7 @@ export async function handleReopenSlice(params, basePath) {
             guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
             return;
         }
-        if (slice.status !== "complete" && slice.status !== "done") {
+        if (!isClosedStatus(slice.status)) {
             guardError = `slice ${params.sliceId} is not complete (status: ${slice.status}) — nothing to reopen`;
             return;
         }

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

@@ -10,6 +10,7 @@
 // Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
 import { getMilestone, getSlice, getTask, updateTaskStatus, transaction, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
@@ -32,7 +33,7 @@ export async function handleReopenTask(params, basePath) {
             guardError = `milestone not found: ${params.milestoneId}`;
             return;
         }
-        if (milestone.status === "complete" || milestone.status === "done") {
+        if (isClosedStatus(milestone.status)) {
             guardError = `cannot reopen task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
             return;
         }
@@ -41,8 +42,8 @@ export async function handleReopenTask(params, basePath) {
             guardError = `slice not found: ${params.milestoneId}/${params.sliceId}`;
             return;
         }
-        if (slice.status === "complete" || slice.status === "done") {
-            guardError = `cannot reopen task inside a closed slice: ${params.sliceId} (status: ${slice.status}) — use gsd_slice_reopen first`;
+        if (isClosedStatus(slice.status)) {
+            guardError = `cannot reopen task in a closed slice: ${params.sliceId} (status: ${slice.status}) — use gsd_slice_reopen first`;
             return;
         }
         const task = getTask(params.milestoneId, params.sliceId, params.taskId);
@@ -50,7 +51,7 @@ export async function handleReopenTask(params, basePath) {
             guardError = `task not found: ${params.milestoneId}/${params.sliceId}/${params.taskId}`;
             return;
         }
-        if (task.status !== "complete" && task.status !== "done") {
+        if (!isClosedStatus(task.status)) {
             guardError = `task ${params.taskId} is not complete (status: ${task.status}) — nothing to reopen`;
             return;
         }

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

@@ -1,13 +1,12 @@
 import { clearParseCache } from "../files.js";
 import { transaction, getSlice, getSliceTasks, getTask, insertTask, upsertTaskPlanning, insertReplanHistory, deleteTask, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
+import { isClosedStatus } from "../status-guards.js";
+import { isNonEmptyString } from "../validation.js";
 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";
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim().length > 0;
-}
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -59,7 +58,7 @@ export async function handleReplanSlice(rawParams, basePath) {
                 guardError = `missing parent slice: ${params.milestoneId}/${params.sliceId}`;
                 return;
             }
-            if (parentSlice.status === "complete" || parentSlice.status === "done") {
+            if (isClosedStatus(parentSlice.status)) {
                 guardError = `cannot replan a closed slice: ${params.sliceId} (status: ${parentSlice.status})`;
                 return;
             }
@@ -69,7 +68,7 @@ export async function handleReplanSlice(rawParams, basePath) {
                 guardError = `blockerTaskId not found: ${params.milestoneId}/${params.sliceId}/${params.blockerTaskId}`;
                 return;
             }
-            if (blockerTask.status !== "complete" && blockerTask.status !== "done") {
+            if (!isClosedStatus(blockerTask.status)) {
                 guardError = `blockerTaskId ${params.blockerTaskId} is not complete (status: ${blockerTask.status}) — the blocker task must be finished before a replan is triggered`;
                 return;
             }
@@ -77,7 +76,7 @@ export async function handleReplanSlice(rawParams, basePath) {
             const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
             const completedTaskIds = new Set();
             for (const task of existingTasks) {
-                if (task.status === "complete" || task.status === "done") {
+                if (isClosedStatus(task.status)) {
                     completedTaskIds.add(task.id);
                 }
             }

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

@@ -0,0 +1,21 @@
+/**
+ * Shared input-validation primitives for GSD tool handlers.
+ */
+/** Type guard: value is a string with at least one non-whitespace character. */
+export function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/**
+ * Validate that `value` is an array of non-empty strings.
+ * Throws with a message referencing `field` on failure.
+ * Returns the validated array (narrowed to string[]).
+ */
+export function validateStringArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} must be an array`);
+    }
+    if (value.some((item) => !isNonEmptyString(item))) {
+        throw new Error(`${field} must contain only non-empty strings`);
+    }
+    return value;
+}

package/dist/resources/extensions/shared/rtk.js

@@ -4,6 +4,7 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 const GSD_RTK_PATH_ENV = "GSD_RTK_PATH";
 const GSD_RTK_DISABLED_ENV = "GSD_RTK_DISABLED";
+const GSD_RTK_REWRITE_TIMEOUT_MS_ENV = "GSD_RTK_REWRITE_TIMEOUT_MS";
 const RTK_TELEMETRY_DISABLED_ENV = "RTK_TELEMETRY_DISABLED";
 const RTK_REWRITE_TIMEOUT_MS = 5_000;
 function isTruthy(value) {
@@ -12,6 +13,13 @@ function isTruthy(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === "1" || normalized === "true" || normalized === "yes";
 }
+function getRewriteTimeoutMs(env = process.env) {
+    const configured = Number.parseInt(env[GSD_RTK_REWRITE_TIMEOUT_MS_ENV] ?? "", 10);
+    if (Number.isFinite(configured) && configured > 0) {
+        return configured;
+    }
+    return RTK_REWRITE_TIMEOUT_MS;
+}
 export function isRtkEnabled(env = process.env) {
     return !isTruthy(env[GSD_RTK_DISABLED_ENV]);
 }
@@ -75,19 +83,21 @@ export function resolveRtkBinaryPath(options = {}) {
     }
     return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform);
 }
-export function rewriteCommandWithRtk(command, env = process.env) {
+export function rewriteCommandWithRtk(command, options = {}) {
+    const env = options.env ?? process.env;
     if (!command.trim())
         return command;
     if (!isRtkEnabled(env))
         return command;
-    const binaryPath = resolveRtkBinaryPath({ env });
+    const binaryPath = options.binaryPath ?? resolveRtkBinaryPath({ env });
     if (!binaryPath)
         return command;
-    const result = spawnSync(binaryPath, ["rewrite", command], {
+    const run = options.spawnSyncImpl ?? spawnSync;
+    const result = run(binaryPath, ["rewrite", command], {
         encoding: "utf-8",
         env: buildRtkEnv(env),
         stdio: ["ignore", "pipe", "ignore"],
-        timeout: RTK_REWRITE_TIMEOUT_MS,
+        timeout: getRewriteTimeoutMs(env),
         // .cmd/.bat wrappers (used by fake-rtk in tests) require shell:true on Windows
         shell: /\.(cmd|bat)$/i.test(binaryPath),
     });

package/dist/rtk.js

@@ -175,7 +175,9 @@ function resolveSystemRtkPath(pathValue, platform = process.platform) {
 export function resolveRtkBinaryPath(options = {}) {
     const env = options.env ?? process.env;
     const platform = options.platform ?? process.platform;
-    const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV];
+    if (options.binaryPath)
+        return options.binaryPath;
+    const explicitPath = env[GSD_RTK_PATH_ENV];
     if (explicitPath && existsSync(explicitPath)) {
         return explicitPath;
     }

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

@@ -1 +1 @@
-vlgS2rkXjxeKhgXhdp4lh
+YO-PWFRitlHM-L-dotlmm

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

@@ -1,46 +1,46 @@
 {
   "/_global-error/page": "/_global-error",
   "/_not-found/page": "/_not-found",
-  "/api/boot/route": "/api/boot",
   "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
+  "/api/boot/route": "/api/boot",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
-  "/api/dev-mode/route": "/api/dev-mode",
   "/api/cleanup/route": "/api/cleanup",
-  "/api/browse-directories/route": "/api/browse-directories",
   "/api/export-data/route": "/api/export-data",
-  "/api/forensics/route": "/api/forensics",
   "/api/doctor/route": "/api/doctor",
-  "/api/git/route": "/api/git",
+  "/api/browse-directories/route": "/api/browse-directories",
+  "/api/dev-mode/route": "/api/dev-mode",
   "/api/captures/route": "/api/captures",
-  "/api/experimental/route": "/api/experimental",
-  "/api/inspect/route": "/api/inspect",
-  "/api/hooks/route": "/api/hooks",
   "/api/history/route": "/api/history",
+  "/api/forensics/route": "/api/forensics",
+  "/api/git/route": "/api/git",
+  "/api/hooks/route": "/api/hooks",
+  "/api/inspect/route": "/api/inspect",
+  "/api/live-state/route": "/api/live-state",
   "/api/knowledge/route": "/api/knowledge",
+  "/api/experimental/route": "/api/experimental",
   "/api/preferences/route": "/api/preferences",
-  "/api/live-state/route": "/api/live-state",
   "/api/recovery/route": "/api/recovery",
-  "/api/projects/route": "/api/projects",
-  "/api/session/browser/route": "/api/session/browser",
   "/api/onboarding/route": "/api/onboarding",
-  "/api/files/route": "/api/files",
+  "/api/session/browser/route": "/api/session/browser",
+  "/api/projects/route": "/api/projects",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/session/command/route": "/api/session/command",
-  "/api/settings-data/route": "/api/settings-data",
+  "/api/skill-health/route": "/api/skill-health",
   "/api/session/events/route": "/api/session/events",
+  "/api/settings-data/route": "/api/settings-data",
   "/api/shutdown/route": "/api/shutdown",
-  "/api/session/manage/route": "/api/session/manage",
-  "/api/skill-health/route": "/api/skill-health",
   "/api/steer/route": "/api/steer",
+  "/api/terminal/resize/route": "/api/terminal/resize",
   "/api/switch-root/route": "/api/switch-root",
+  "/api/files/route": "/api/files",
   "/api/terminal/input/route": "/api/terminal/input",
-  "/api/terminal/resize/route": "/api/terminal/resize",
-  "/api/terminal/sessions/route": "/api/terminal/sessions",
-  "/api/undo/route": "/api/undo",
-  "/api/remote-questions/route": "/api/remote-questions",
-  "/api/update/route": "/api/update",
   "/api/visualizer/route": "/api/visualizer",
   "/api/terminal/stream/route": "/api/terminal/stream",
+  "/api/undo/route": "/api/undo",
+  "/api/terminal/sessions/route": "/api/terminal/sessions",
+  "/api/update/route": "/api/update",
+  "/api/remote-questions/route": "/api/remote-questions",
   "/api/terminal/upload/route": "/api/terminal/upload",
   "/page": "/"
 }

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

@@ -4,14 +4,14 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/vlgS2rkXjxeKhgXhdp4lh/_buildManifest.js",
-    "static/vlgS2rkXjxeKhgXhdp4lh/_ssgManifest.js"
+    "static/YO-PWFRitlHM-L-dotlmm/_buildManifest.js",
+    "static/YO-PWFRitlHM-L-dotlmm/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/webpack-024d82be84800e52.js",
+    "static/chunks/webpack-bca0e732db0dcec3.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": "a771cbd7151fe8792440248f74a9eee9",
-    "previewModeSigningKey": "06c08aa13e30bbf98adc75382278314fd126424a2c85de220467482119ad407e",
-    "previewModeEncryptionKey": "44023b0b0e864966518a457214e9fc1cead59218ead80a8e34e0d5758d8a9d9d"
+    "previewModeId": "01331f5d86acc7be1d3ecc8d5855e334",
+    "previewModeSigningKey": "8b6653cdd01c63bde017b6a42df870bc138ec94025546cdb71ac3548cfea7fa6",
+    "previewModeEncryptionKey": "2d7b20c003d03450d2f327b36c6e5db81437c825c1417b0299956d4083d83ea7"
   }
 }

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/4024.21054f459af5cc78.js"
+      "static/chunks/4024.87fd909ae0110f50.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",