gsd-pi 2.53.0 → 2.54.0-dev.e1efc1a

package/dist/headless-ui.d.ts

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

package/dist/headless-ui.js

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

package/dist/headless.d.ts

@@ -11,6 +11,7 @@
  *   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;
@@ -31,5 +32,15 @@ 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,12 +14,35 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolve } from 'node:path';
-import { RpcClient } from '@gsd/pi-coding-agent';
+import { RpcClient, SessionManager } from '@gsd/pi-coding-agent';
+import { getProjectSessionsDir } from './project-sessions.js';
 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, } 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, mapStatusToExitCode, } 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
 // ---------------------------------------------------------------------------
@@ -256,6 +279,39 @@ 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');
@@ -272,8 +328,11 @@ async function runHeadlessOnce(options, restartCount) {
         if (recentEvents.length > 20)
             recentEvents.shift();
     }
-    // Stdin writer for sending extension_ui_response to child
-    let stdinWriter = null;
+    // 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 = () => { };
     // Supervised mode state
     const pendingResponseTimers = new Map();
     let supervisedFallback = false;
@@ -320,21 +379,54 @@ async function runHeadlessOnce(options, restartCount) {
         resetIdleTimer();
         // Answer injector: observe events for question metadata
         injector?.observeEvent(eventObj);
-        // --json mode: forward events as JSONL to stdout (filtered if --events)
-        if (options.json) {
+        // --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') {
             const eventType = String(eventObj.type ?? '');
             if (!options.eventFilter || options.eventFilter.has(eventType)) {
                 process.stdout.write(JSON.stringify(eventObj) + '\n');
             }
         }
-        else {
+        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) {
             // 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' && stdinWriter) {
+        if (eventObj.type === 'extension_ui_request' && clientStarted) {
             // Check for terminal notification before auto-responding
             if (isBlockedNotification(eventObj)) {
                 blocked = true;
@@ -348,7 +440,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, stdinWriter)) {
+                if (injector.tryHandle(eventObj, injectorStdinAdapter)) {
                     if (completed) {
                         exitCode = blocked ? EXIT_BLOCKED : EXIT_SUCCESS;
                         resolveCompletion();
@@ -364,13 +456,13 @@ async function runHeadlessOnce(options, restartCount) {
                 const eventId = String(eventObj.id ?? '');
                 const timer = setTimeout(() => {
                     pendingResponseTimers.delete(eventId);
-                    handleExtensionUIRequest(eventObj, stdinWriter);
+                    handleExtensionUIRequest(eventObj, client);
                     process.stdout.write(JSON.stringify({ type: 'supervised_timeout', id: eventId, method }) + '\n');
                 }, responseTimeout);
                 pendingResponseTimers.set(eventId, timer);
             }
             else {
-                handleExtensionUIRequest(eventObj, stdinWriter);
+                handleExtensionUIRequest(eventObj, client);
             }
             // If we detected a terminal notification, resolve after responding
             if (completed) {
@@ -393,13 +485,22 @@ async function runHeadlessOnce(options, restartCount) {
         process.stderr.write('\n[headless] Interrupted, stopping child process...\n');
         interrupted = true;
         exitCode = EXIT_CANCELLED;
-        client.stop().finally(() => {
-            if (timeoutTimer)
-                clearTimeout(timeoutTimer);
-            if (idleTimer)
-                clearTimeout(idleTimer);
-            process.exit(exitCode);
-        });
+        // 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);
     };
     process.on('SIGINT', signalHandler);
     process.on('SIGTERM', signalHandler);
@@ -413,21 +514,55 @@ async function runHeadlessOnce(options, restartCount) {
             clearTimeout(timeoutTimer);
         process.exit(1);
     }
-    // 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);
+    // v2 protocol negotiation — attempt init for structured completion events
+    let v2Enabled = false;
+    try {
+        await client.init({ clientId: 'gsd-headless' });
+        v2Enabled = true;
     }
-    stdinWriter = (data) => {
-        internalProcess.stdin.write(data);
+    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`);
+    }
+    // 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');
+        }
     };
     // Start supervised stdin reader for orchestrator commands
     if (options.supervised) {
-        stopSupervisedReader = startSupervisedStdinReader(stdinWriter, client, (id) => {
+        stopSupervisedReader = startSupervisedStdinReader(client, (id) => {
             const timer = pendingResponseTimers.get(id);
             if (timer) {
                 clearTimeout(timer);
@@ -437,15 +572,18 @@ async function runHeadlessOnce(options, restartCount) {
         // Ensure stdin is in flowing mode for JSONL reading
         process.stdin.resume();
     }
-    // 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();
-        }
-    });
+    // 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();
+            }
+        });
+    }
     if (!options.json) {
         process.stderr.write(`[headless] Running /gsd ${options.command}${options.commandArgs.length > 0 ? ' ' + options.commandArgs.join(' ') : ''}...\n`);
     }
@@ -530,5 +668,7 @@ 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 @@
-mWBOLPnUoeaTGiD-vhu5O
+nISuDzAIpGYC-DVTvs4Po

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

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

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

@@ -4,14 +4,14 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/mWBOLPnUoeaTGiD-vhu5O/_buildManifest.js",
-    "static/mWBOLPnUoeaTGiD-vhu5O/_ssgManifest.js"
+    "static/nISuDzAIpGYC-DVTvs4Po/_buildManifest.js",
+    "static/nISuDzAIpGYC-DVTvs4Po/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "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": "d295367633ac46f8d8b141bc50fa0ae0",
-    "previewModeSigningKey": "544b70ab915f56609f2afe474d867f217ec3842f3ef6b58de09607bbafb0e432",
-    "previewModeEncryptionKey": "389e809ac429411dec37ec0518d948521954643fc0f04066066ec0af454d99a5"
+    "previewModeId": "421c8ae4252416128c6285506cccf021",
+    "previewModeSigningKey": "55cb8a1dd17e322add989f48f333adbf1322c54b5b786db308294dc5891a464c",
+    "previewModeEncryptionKey": "48301e074f6610a318f4af6a7fb298f6ace2a45887285828301e9bba0ace5432"
   }
 }

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": {
@@ -157,7 +157,7 @@
       "proxyPrefetch": "flexible",
       "optimisticClientCache": true,
       "manualClientBasePath": false,
-      "cpus": 9,
+      "cpus": 5,
       "memoryBasedWorkersCount": false,
       "imgOptConcurrency": null,
       "imgOptTimeoutInSeconds": 7,
@@ -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",