gsd-pi 2.53.0-dev.a67436f → 2.53.0

package/dist/headless-ui.d.ts

@@ -18,6 +18,6 @@ interface ExtensionUIRequest {
     [key: string]: unknown;
 }
 export type { ExtensionUIRequest };
-export declare function handleExtensionUIRequest(event: ExtensionUIRequest, client: RpcClient): void;
+export declare function handleExtensionUIRequest(event: ExtensionUIRequest, writeToStdin: (data: string) => void): void;
 export declare function formatProgress(event: Record<string, unknown>, verbose: boolean): string | null;
-export declare function startSupervisedStdinReader(client: RpcClient, onResponse: (id: string) => void): () => void;
+export declare function startSupervisedStdinReader(stdinWriter: (data: string) => void, client: RpcClient, onResponse: (id: string) => void): () => void;

package/dist/headless-ui.js

@@ -5,12 +5,13 @@
  * formats progress events for stderr output, and reads orchestrator
  * commands from stdin in supervised mode.
  */
-import { attachJsonlLineReader } from '@gsd/pi-coding-agent';
+import { attachJsonlLineReader, serializeJsonLine } from '@gsd/pi-coding-agent';
 // ---------------------------------------------------------------------------
 // Extension UI Auto-Responder
 // ---------------------------------------------------------------------------
-export function handleExtensionUIRequest(event, client) {
+export function handleExtensionUIRequest(event, writeToStdin) {
     const { id, method } = event;
+    let response;
     switch (method) {
         case 'select': {
             // Lock-guard prompts list "View status" first, but headless needs "Force start"
@@ -22,30 +23,31 @@ export function handleExtensionUIRequest(event, client) {
                 if (forceOption)
                     selected = forceOption;
             }
-            client.sendUIResponse(id, { value: selected });
+            response = { type: 'extension_ui_response', id, value: selected };
             break;
         }
         case 'confirm':
-            client.sendUIResponse(id, { confirmed: true });
+            response = { type: 'extension_ui_response', id, confirmed: true };
             break;
         case 'input':
-            client.sendUIResponse(id, { value: '' });
+            response = { type: 'extension_ui_response', id, value: '' };
             break;
         case 'editor':
-            client.sendUIResponse(id, { value: event.prefill ?? '' });
+            response = { type: 'extension_ui_response', id, value: event.prefill ?? '' };
             break;
         case 'notify':
         case 'setStatus':
         case 'setWidget':
         case 'setTitle':
         case 'set_editor_text':
-            client.sendUIResponse(id, { value: '' });
+            response = { type: 'extension_ui_response', id, value: '' };
             break;
         default:
             process.stderr.write(`[headless] Warning: unknown extension_ui_request method "${method}", cancelling\n`);
-            client.sendUIResponse(id, { cancelled: true });
+            response = { type: 'extension_ui_response', id, cancelled: true };
             break;
     }
+    writeToStdin(serializeJsonLine(response));
 }
 // ---------------------------------------------------------------------------
 // Progress Formatter
@@ -76,7 +78,7 @@ export function formatProgress(event, verbose) {
 // ---------------------------------------------------------------------------
 // Supervised Stdin Reader
 // ---------------------------------------------------------------------------
-export function startSupervisedStdinReader(client, onResponse) {
+export function startSupervisedStdinReader(stdinWriter, client, onResponse) {
     return attachJsonlLineReader(process.stdin, (line) => {
         let msg;
         try {
@@ -88,17 +90,12 @@ export function startSupervisedStdinReader(client, onResponse) {
         }
         const type = String(msg.type ?? '');
         switch (type) {
-            case 'extension_ui_response': {
-                const id = String(msg.id ?? '');
-                const value = msg.value !== undefined ? String(msg.value) : undefined;
-                const confirmed = typeof msg.confirmed === 'boolean' ? msg.confirmed : undefined;
-                const cancelled = typeof msg.cancelled === 'boolean' ? msg.cancelled : undefined;
-                client.sendUIResponse(id, { value, confirmed, cancelled });
-                if (id) {
-                    onResponse(id);
+            case 'extension_ui_response':
+                stdinWriter(line + '\n');
+                if (typeof msg.id === 'string') {
+                    onResponse(msg.id);
                 }
                 break;
-            }
             case 'prompt':
                 client.prompt(String(msg.message ?? ''));
                 break;

package/dist/headless.d.ts

@@ -11,7 +11,6 @@
  *   10 — blocked (command reported a blocker)
  *   11 — cancelled (SIGINT/SIGTERM received)
  */
-import type { SessionInfo } from '@gsd/pi-coding-agent';
 import type { OutputFormat } from './headless-types.js';
 export interface HeadlessOptions {
     timeout: number;
@@ -32,15 +31,5 @@ export interface HeadlessOptions {
     resumeSession?: string;
     bare?: boolean;
 }
-export interface ResumeSessionResult {
-    session?: SessionInfo;
-    error?: string;
-}
-/**
- * Resolve a session prefix to a single session.
- * Exact id match is preferred over prefix match.
- * Returns `{ session }` on unique match or `{ error }` on 0/ambiguous matches.
- */
-export declare function resolveResumeSession(sessions: SessionInfo[], prefix: string): ResumeSessionResult;
 export declare function parseHeadlessArgs(argv: string[]): HeadlessOptions;
 export declare function runHeadless(options: HeadlessOptions): Promise<void>;

package/dist/headless.js

@@ -14,35 +14,12 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolve } from 'node:path';
-import { RpcClient, SessionManager } from '@gsd/pi-coding-agent';
-import { getProjectSessionsDir } from './project-sessions.js';
+import { RpcClient } from '@gsd/pi-coding-agent';
 import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';
-import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, mapStatusToExitCode, } from './headless-events.js';
+import { isTerminalNotification, isBlockedNotification, isMilestoneReadyNotification, isQuickCommand, FIRE_AND_FORGET_METHODS, IDLE_TIMEOUT_MS, NEW_MILESTONE_IDLE_TIMEOUT_MS, EXIT_SUCCESS, EXIT_ERROR, EXIT_BLOCKED, EXIT_CANCELLED, } from './headless-events.js';
 import { VALID_OUTPUT_FORMATS } from './headless-types.js';
 import { handleExtensionUIRequest, formatProgress, startSupervisedStdinReader, } from './headless-ui.js';
 import { loadContext, bootstrapGsdProject, } from './headless-context.js';
-/**
- * Resolve a session prefix to a single session.
- * Exact id match is preferred over prefix match.
- * Returns `{ session }` on unique match or `{ error }` on 0/ambiguous matches.
- */
-export function resolveResumeSession(sessions, prefix) {
-    // Exact match takes priority
-    const exact = sessions.find(s => s.id === prefix);
-    if (exact) {
-        return { session: exact };
-    }
-    // Prefix match
-    const matches = sessions.filter(s => s.id.startsWith(prefix));
-    if (matches.length === 0) {
-        return { error: `No session matching '${prefix}' found` };
-    }
-    if (matches.length > 1) {
-        const list = matches.map(s => `  ${s.id}`).join('\n');
-        return { error: `Ambiguous session prefix '${prefix}' matches ${matches.length} sessions:\n${list}` };
-    }
-    return { session: matches[0] };
-}
 // ---------------------------------------------------------------------------
 // CLI Argument Parser
 // ---------------------------------------------------------------------------
@@ -279,39 +256,6 @@ async function runHeadlessOnce(options, restartCount) {
     let exitCode = 0;
     let milestoneReady = false; // tracks "Milestone X ready." for auto-chaining
     const recentEvents = [];
-    // JSON batch mode: cost aggregation (cumulative-max pattern per K004)
-    let cumulativeCostUsd = 0;
-    let cumulativeInputTokens = 0;
-    let cumulativeOutputTokens = 0;
-    let cumulativeCacheReadTokens = 0;
-    let cumulativeCacheWriteTokens = 0;
-    let lastSessionId;
-    // Emit HeadlessJsonResult to stdout for --output-format json batch mode
-    function emitBatchJsonResult() {
-        if (options.outputFormat !== 'json')
-            return;
-        const duration = Date.now() - startTime;
-        const status = blocked ? 'blocked'
-            : exitCode === EXIT_CANCELLED ? 'cancelled'
-                : exitCode === EXIT_ERROR ? (totalEvents === 0 ? 'error' : 'timeout')
-                    : 'success';
-        const result = {
-            status,
-            exitCode,
-            sessionId: lastSessionId,
-            duration,
-            cost: {
-                total: cumulativeCostUsd,
-                input_tokens: cumulativeInputTokens,
-                output_tokens: cumulativeOutputTokens,
-                cache_read_tokens: cumulativeCacheReadTokens,
-                cache_write_tokens: cumulativeCacheWriteTokens,
-            },
-            toolCalls: toolCallCount,
-            events: totalEvents,
-        };
-        process.stdout.write(JSON.stringify(result) + '\n');
-    }
     function trackEvent(event) {
         totalEvents++;
         const type = String(event.type ?? 'unknown');
@@ -328,11 +272,8 @@ async function runHeadlessOnce(options, restartCount) {
         if (recentEvents.length > 20)
             recentEvents.shift();
     }
-    // Client started flag — replaces old stdinWriter null-check
-    let clientStarted = false;
-    // Adapter for AnswerInjector — wraps client.sendUIResponse in a writeToStdin-compatible callback
-    // Initialized after client.start(); events won't fire before then
-    let injectorStdinAdapter = () => { };
+    // Stdin writer for sending extension_ui_response to child
+    let stdinWriter = null;
     // Supervised mode state
     const pendingResponseTimers = new Map();
     let supervisedFallback = false;
@@ -379,54 +320,21 @@ async function runHeadlessOnce(options, restartCount) {
         resetIdleTimer();
         // Answer injector: observe events for question metadata
         injector?.observeEvent(eventObj);
-        // --json / --output-format stream-json: forward events as JSONL to stdout (filtered if --events)
-        // --output-format json (batch mode): suppress streaming, track cost for final result
-        if (options.json && options.outputFormat === 'stream-json') {
+        // --json mode: forward events as JSONL to stdout (filtered if --events)
+        if (options.json) {
             const eventType = String(eventObj.type ?? '');
             if (!options.eventFilter || options.eventFilter.has(eventType)) {
                 process.stdout.write(JSON.stringify(eventObj) + '\n');
             }
         }
-        else if (options.outputFormat === 'json') {
-            // Batch mode: silently track cost_update events (cumulative-max per K004)
-            const eventType = String(eventObj.type ?? '');
-            if (eventType === 'cost_update') {
-                const data = eventObj;
-                const cumCost = data.cumulativeCost;
-                if (cumCost) {
-                    cumulativeCostUsd = Math.max(cumulativeCostUsd, Number(cumCost.costUsd ?? 0));
-                    const tokens = data.tokens;
-                    if (tokens) {
-                        cumulativeInputTokens = Math.max(cumulativeInputTokens, tokens.input ?? 0);
-                        cumulativeOutputTokens = Math.max(cumulativeOutputTokens, tokens.output ?? 0);
-                        cumulativeCacheReadTokens = Math.max(cumulativeCacheReadTokens, tokens.cacheRead ?? 0);
-                        cumulativeCacheWriteTokens = Math.max(cumulativeCacheWriteTokens, tokens.cacheWrite ?? 0);
-                    }
-                }
-            }
-            // Track sessionId from init_result
-            if (eventType === 'init_result') {
-                lastSessionId = String(eventObj.sessionId ?? '');
-            }
-        }
-        else if (!options.json) {
+        else {
             // Progress output to stderr
             const line = formatProgress(eventObj, !!options.verbose);
             if (line)
                 process.stderr.write(line + '\n');
         }
-        // Handle execution_complete (v2 structured completion)
-        if (eventObj.type === 'execution_complete' && !completed) {
-            completed = true;
-            const status = String(eventObj.status ?? 'success');
-            exitCode = mapStatusToExitCode(status);
-            if (eventObj.status === 'blocked')
-                blocked = true;
-            resolveCompletion();
-            return;
-        }
         // Handle extension_ui_request
-        if (eventObj.type === 'extension_ui_request' && clientStarted) {
+        if (eventObj.type === 'extension_ui_request' && stdinWriter) {
             // Check for terminal notification before auto-responding
             if (isBlockedNotification(eventObj)) {
                 blocked = true;
@@ -440,7 +348,7 @@ async function runHeadlessOnce(options, restartCount) {
             }
             // Answer injection: try to handle with pre-supplied answers before supervised/auto
             if (injector && !FIRE_AND_FORGET_METHODS.has(String(eventObj.method ?? ''))) {
-                if (injector.tryHandle(eventObj, injectorStdinAdapter)) {
+                if (injector.tryHandle(eventObj, stdinWriter)) {
                     if (completed) {
                         exitCode = blocked ? EXIT_BLOCKED : EXIT_SUCCESS;
                         resolveCompletion();
@@ -456,13 +364,13 @@ async function runHeadlessOnce(options, restartCount) {
                 const eventId = String(eventObj.id ?? '');
                 const timer = setTimeout(() => {
                     pendingResponseTimers.delete(eventId);
-                    handleExtensionUIRequest(eventObj, client);
+                    handleExtensionUIRequest(eventObj, stdinWriter);
                     process.stdout.write(JSON.stringify({ type: 'supervised_timeout', id: eventId, method }) + '\n');
                 }, responseTimeout);
                 pendingResponseTimers.set(eventId, timer);
             }
             else {
-                handleExtensionUIRequest(eventObj, client);
+                handleExtensionUIRequest(eventObj, stdinWriter);
             }
             // If we detected a terminal notification, resolve after responding
             if (completed) {
@@ -485,22 +393,13 @@ async function runHeadlessOnce(options, restartCount) {
         process.stderr.write('\n[headless] Interrupted, stopping child process...\n');
         interrupted = true;
         exitCode = EXIT_CANCELLED;
-        // Kill child process — don't await, just fire and exit.
-        // The main flow may be awaiting a promise that resolves when the child dies,
-        // which would race with this handler. Exit synchronously to ensure correct exit code.
-        try {
-            client.stop().catch(() => { });
-        }
-        catch { }
-        if (timeoutTimer)
-            clearTimeout(timeoutTimer);
-        if (idleTimer)
-            clearTimeout(idleTimer);
-        // Emit batch JSON result if in json mode before exiting
-        if (options.outputFormat === 'json') {
-            emitBatchJsonResult();
-        }
-        process.exit(exitCode);
+        client.stop().finally(() => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            process.exit(exitCode);
+        });
     };
     process.on('SIGINT', signalHandler);
     process.on('SIGTERM', signalHandler);
@@ -514,55 +413,21 @@ async function runHeadlessOnce(options, restartCount) {
             clearTimeout(timeoutTimer);
         process.exit(1);
     }
-    // v2 protocol negotiation — attempt init for structured completion events
-    let v2Enabled = false;
-    try {
-        await client.init({ clientId: 'gsd-headless' });
-        v2Enabled = true;
-    }
-    catch {
-        process.stderr.write('[headless] Warning: v2 init failed, falling back to v1 string-matching\n');
-    }
-    clientStarted = true;
-    // --resume: resolve session ID and switch to it
-    if (options.resumeSession) {
-        const projectSessionsDir = getProjectSessionsDir(process.cwd());
-        const sessions = await SessionManager.list(process.cwd(), projectSessionsDir);
-        const result = resolveResumeSession(sessions, options.resumeSession);
-        if (result.error) {
-            process.stderr.write(`[headless] Error: ${result.error}\n`);
-            await client.stop();
-            if (timeoutTimer)
-                clearTimeout(timeoutTimer);
-            process.exit(1);
-        }
-        const matched = result.session;
-        const switchResult = await client.switchSession(matched.path);
-        if (switchResult.cancelled) {
-            process.stderr.write(`[headless] Error: Session switch to '${matched.id}' was cancelled by an extension\n`);
-            await client.stop();
-            if (timeoutTimer)
-                clearTimeout(timeoutTimer);
-            process.exit(1);
-        }
-        process.stderr.write(`[headless] Resuming session ${matched.id}\n`);
+    // Access stdin writer from the internal process
+    const internalProcess = client.process;
+    if (!internalProcess?.stdin) {
+        process.stderr.write('[headless] Error: Cannot access child process stdin\n');
+        await client.stop();
+        if (timeoutTimer)
+            clearTimeout(timeoutTimer);
+        process.exit(1);
     }
-    // Build injector adapter — wraps client.sendUIResponse for AnswerInjector's writeToStdin interface
-    injectorStdinAdapter = (data) => {
-        try {
-            const parsed = JSON.parse(data.trim());
-            if (parsed.type === 'extension_ui_response' && parsed.id) {
-                const { id, value, values, confirmed, cancelled } = parsed;
-                client.sendUIResponse(id, { value, values, confirmed, cancelled });
-            }
-        }
-        catch {
-            process.stderr.write('[headless] Warning: injector adapter received unparseable data\n');
-        }
+    stdinWriter = (data) => {
+        internalProcess.stdin.write(data);
     };
     // Start supervised stdin reader for orchestrator commands
     if (options.supervised) {
-        stopSupervisedReader = startSupervisedStdinReader(client, (id) => {
+        stopSupervisedReader = startSupervisedStdinReader(stdinWriter, client, (id) => {
             const timer = pendingResponseTimers.get(id);
             if (timer) {
                 clearTimeout(timer);
@@ -572,18 +437,15 @@ async function runHeadlessOnce(options, restartCount) {
         // Ensure stdin is in flowing mode for JSONL reading
         process.stdin.resume();
     }
-    // Detect child process crash (read-only exit event subscription — not stdin access)
-    const internalProcess = client.process;
-    if (internalProcess) {
-        internalProcess.on('exit', (code) => {
-            if (!completed) {
-                const msg = `[headless] Child process exited unexpectedly with code ${code ?? 'null'}\n`;
-                process.stderr.write(msg);
-                exitCode = EXIT_ERROR;
-                resolveCompletion();
-            }
-        });
-    }
+    // Detect child process crash
+    internalProcess.on('exit', (code) => {
+        if (!completed) {
+            const msg = `[headless] Child process exited unexpectedly with code ${code ?? 'null'}\n`;
+            process.stderr.write(msg);
+            exitCode = EXIT_ERROR;
+            resolveCompletion();
+        }
+    });
     if (!options.json) {
         process.stderr.write(`[headless] Running /gsd ${options.command}${options.commandArgs.length > 0 ? ' ' + options.commandArgs.join(' ') : ''}...\n`);
     }
@@ -668,7 +530,5 @@ async function runHeadlessOnce(options, restartCount) {
             }
         }
     }
-    // Emit structured JSON result in batch mode
-    emitBatchJsonResult();
     return { exitCode, interrupted };
 }

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

@@ -1 +1 @@
-YO-PWFRitlHM-L-dotlmm
+mWBOLPnUoeaTGiD-vhu5O

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/bridge-terminal/input/route": "/api/bridge-terminal/input",
-  "/api/boot/route": "/api/boot",
+  "/_global-error/page": "/_global-error",
   "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
+  "/api/boot/route": "/api/boot",
+  "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
+  "/api/dev-mode/route": "/api/dev-mode",
   "/api/cleanup/route": "/api/cleanup",
-  "/api/export-data/route": "/api/export-data",
   "/api/doctor/route": "/api/doctor",
   "/api/browse-directories/route": "/api/browse-directories",
-  "/api/dev-mode/route": "/api/dev-mode",
-  "/api/captures/route": "/api/captures",
-  "/api/history/route": "/api/history",
+  "/api/export-data/route": "/api/export-data",
   "/api/forensics/route": "/api/forensics",
+  "/api/captures/route": "/api/captures",
   "/api/git/route": "/api/git",
+  "/api/history/route": "/api/history",
   "/api/hooks/route": "/api/hooks",
-  "/api/inspect/route": "/api/inspect",
-  "/api/live-state/route": "/api/live-state",
   "/api/knowledge/route": "/api/knowledge",
+  "/api/inspect/route": "/api/inspect",
   "/api/experimental/route": "/api/experimental",
+  "/api/live-state/route": "/api/live-state",
   "/api/preferences/route": "/api/preferences",
   "/api/recovery/route": "/api/recovery",
   "/api/onboarding/route": "/api/onboarding",
-  "/api/session/browser/route": "/api/session/browser",
   "/api/projects/route": "/api/projects",
-  "/api/session/manage/route": "/api/session/manage",
+  "/api/session/browser/route": "/api/session/browser",
   "/api/session/command/route": "/api/session/command",
-  "/api/skill-health/route": "/api/skill-health",
   "/api/session/events/route": "/api/session/events",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/settings-data/route": "/api/settings-data",
   "/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/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/visualizer/route": "/api/visualizer",
+  "/api/terminal/sessions/route": "/api/terminal/sessions",
   "/api/terminal/stream/route": "/api/terminal/stream",
   "/api/undo/route": "/api/undo",
-  "/api/terminal/sessions/route": "/api/terminal/sessions",
+  "/api/files/route": "/api/files",
+  "/api/terminal/upload/route": "/api/terminal/upload",
+  "/api/visualizer/route": "/api/visualizer",
   "/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/YO-PWFRitlHM-L-dotlmm/_buildManifest.js",
-    "static/YO-PWFRitlHM-L-dotlmm/_ssgManifest.js"
+    "static/mWBOLPnUoeaTGiD-vhu5O/_buildManifest.js",
+    "static/mWBOLPnUoeaTGiD-vhu5O/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-bca0e732db0dcec3.js",
     "static/chunks/4bd1b696-e5d7c65570c947b7.js",
     "static/chunks/3794-337d1ca25ad99a89.js",
-    "static/chunks/main-app-fdab67f7802d7832.js"
+    "static/chunks/main-app-d3d4c336195465f9.js"
   ],
   "rootMainFilesTree": {},
   "pages": {

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

@@ -78,8 +78,8 @@
   "dynamicRoutes": {},
   "notFoundRoutes": [],
   "preview": {
-    "previewModeId": "01331f5d86acc7be1d3ecc8d5855e334",
-    "previewModeSigningKey": "8b6653cdd01c63bde017b6a42df870bc138ec94025546cdb71ac3548cfea7fa6",
-    "previewModeEncryptionKey": "2d7b20c003d03450d2f327b36c6e5db81437c825c1417b0299956d4083d83ea7"
+    "previewModeId": "d295367633ac46f8d8b141bc50fa0ae0",
+    "previewModeSigningKey": "544b70ab915f56609f2afe474d867f217ec3842f3ef6b58de09607bbafb0e432",
+    "previewModeEncryptionKey": "389e809ac429411dec37ec0518d948521954643fc0f04066066ec0af454d99a5"
   }
 }

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

@@ -100,7 +100,7 @@
         "transform": "lodash/{{member}}"
       }
     },
-    "outputFileTracingRoot": "/__w/gsd-2/gsd-2",
+    "outputFileTracingRoot": "/home/runner/_work/gsd-2/gsd-2",
     "cacheComponents": false,
     "cacheLife": {
       "default": {
@@ -157,7 +157,7 @@
       "proxyPrefetch": "flexible",
       "optimisticClientCache": true,
       "manualClientBasePath": false,
-      "cpus": 5,
+      "cpus": 9,
       "memoryBasedWorkersCount": false,
       "imgOptConcurrency": null,
       "imgOptTimeoutInSeconds": 7,
@@ -297,11 +297,11 @@
       "node-pty"
     ],
     "turbopack": {
-      "root": "/__w/gsd-2/gsd-2"
+      "root": "/home/runner/_work/gsd-2/gsd-2"
     },
     "distDirRoot": ".next"
   },
-  "appDir": "/__w/gsd-2/gsd-2/web",
+  "appDir": "/home/runner/_work/gsd-2/gsd-2/web",
   "relativeAppDir": "web",
   "files": [
     ".next/routes-manifest.json",