@xfey/tutti 0.1.10 → 0.1.12

package/dist/providers/openai/app-server/workspace-write-run.d.ts

@@ -1,6 +1,7 @@
 import type { ActivityRef, TaskId } from "@tutti/shared/ids";
 import type { CodexAppServerApprovalPolicy } from "../codex-app-server.js";
 import { type CodexAppServerJsonRpcError, type CodexAppServerJsonRpcServerRequest } from "./json-rpc.js";
+import { type CodexAppServerRuntimeTelemetryOptions } from "./runtime-telemetry.js";
 import { type CodexAppServerAgentContextRuntime, type CodexAppServerSkillSelectionName } from "./skills.js";
 import { type OpenAiTokenUsage } from "../token-usage.js";
 export type CodexAppServerApprovalsReviewer = "user" | "auto_review" | "guardian_subagent";
@@ -53,6 +54,7 @@ export type CodexAppServerWorkspaceWriteRunInput<TOutput> = {
     requestTimeoutMs?: number;
     turnTimeoutMs?: number;
     baseEnv?: NodeJS.ProcessEnv;
+    runtimeTelemetry?: CodexAppServerRuntimeTelemetryOptions;
 };
 export type CodexAppServerWorkspaceWriteRunResult<TOutput> = {
     output: TOutput;

package/dist/providers/openai/app-server/workspace-write-run.js

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { buildCodexAppServerProcessPlan } from "../codex-app-server.js";
 import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
 import { CodexAppServerJsonRpcClient, CodexAppServerProtocolError, } from "./json-rpc.js";
+import { createCodexAppServerRuntimeObserver, } from "./runtime-telemetry.js";
 import { createWorkspaceWriteSandboxPolicy } from "./sandbox-policy.js";
 import { buildCodexAppServerProviderConfigOverrides, resolveCodexAppServerModelProvider, } from "./provider-config.js";
 import { buildCodexAppServerTurnInput, resolveCodexAppServerContextRuntimeHint, resolveCodexAppServerSkillsListWarmup, resolveCodexAppServerSkillInputs, CodexAppServerSkillSelectionError, } from "./skills.js";
@@ -201,7 +202,17 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
         env: createCodexSpawnEnv(codexHome, options.baseEnv ?? process.env),
         stdio: "pipe",
     });
-    const client = new CodexAppServerJsonRpcClient(child);
+    const runtimeObserver = options.runtimeTelemetry === undefined
+        ? undefined
+        : createCodexAppServerRuntimeObserver(options.runtimeTelemetry);
+    const client = new CodexAppServerJsonRpcClient(child, {
+        ...(runtimeObserver === undefined
+            ? {}
+            : {
+                onNotification: runtimeObserver.notification,
+                onServerRequest: runtimeObserver.serverRequest,
+            }),
+    });
     const sensitiveValues = [
         options.apiKey,
         tempRoot,
@@ -370,6 +381,7 @@ export async function runCodexAppServerWorkspaceWriteRun(options) {
         throw new CodexAppServerWorkspaceWriteRunError("app_server_protocol_error", redactWithKnownValues(message, sensitiveValues));
     }
     finally {
+        runtimeObserver?.flush();
         client.dispose();
         rmSync(tempRoot, { recursive: true, force: true });
     }

package/dist/run-engine/index.d.ts

@@ -1,6 +1,6 @@
 import { type ActivityRef, type TaskId } from "@tutti/shared/ids";
 import type { RunLineage } from "@tutti/shared/domain";
-import type { ActivityProjection, ExecutionStatusProjection, TaskProjection } from "@tutti/shared/schemas/api";
+import type { ActivityProjection, ExecutionRuntimeSnapshot, ExecutionStatusProjection, TaskProjection } from "@tutti/shared/schemas/api";
 export type RunTerminalConclusion = {
     kind: "completed";
     summary: string;
@@ -20,6 +20,7 @@ export type RunExecutionContext = {
 export type RunProgressUpdate = {
     summary: string;
     phase?: string;
+    runtime?: ExecutionRuntimeSnapshot;
 };
 export type StartRunOptions = {
     activity_ref?: ActivityRef;

package/dist/run-engine/index.js

@@ -57,7 +57,7 @@ export class RunEngine {
     }
     getExecutionStatus() {
         if (this.active !== null) {
-            return {
+            const status = {
                 status: "running",
                 summary: this.active.activity.summary,
                 active_task: this.active.task,
@@ -70,6 +70,10 @@ export class RunEngine {
                 },
                 updated_at: this.now().toISOString(),
             };
+            if (this.active.runtime !== undefined) {
+                status.runtime = this.active.runtime;
+            }
+            return status;
         }
         const idle = {
             status: "idle",
@@ -106,6 +110,15 @@ export class RunEngine {
             return;
         }
         active.activity.summary = progress.summary;
+        if (progress.runtime !== undefined) {
+            active.runtime = progress.runtime;
+        }
+        else if (progress.phase !== undefined && active.runtime !== undefined) {
+            active.runtime = {
+                ...active.runtime,
+                stage_id: progress.phase,
+            };
+        }
         onTransition?.(this.state("progress", progress));
     }
     finishActive(activityRef, conclusion, onTransition) {

package/dist/run-pipeline/task-run-invocation.js

@@ -109,6 +109,15 @@ export async function runWorkspaceWriteTask(options, input, handle) {
                 : { requestTimeoutMs: options.requestTimeoutMs }),
             ...(options.turnTimeoutMs === undefined ? {} : { turnTimeoutMs: options.turnTimeoutMs }),
             ...(options.baseEnv === undefined ? {} : { baseEnv: options.baseEnv }),
+            runtimeTelemetry: {
+                activityRef: input.activity_ref,
+                stageId: "provider_task_run",
+                onSnapshot: (snapshot) => input.on_stage?.({
+                    stage: "provider_task_run",
+                    summary: "running Codex task implementation.",
+                    runtime: snapshot,
+                }),
+            },
         });
     }
     finally {

package/dist/server-shell/cli/args.d.ts

@@ -5,7 +5,7 @@ export type CliCommand = {
     kind: "version";
 } | {
     kind: "launch";
-    workspacePath: string;
+    target?: string;
     yes: boolean;
     foreground: boolean;
 } | {
@@ -17,29 +17,29 @@ export type CliCommand = {
     manage: boolean;
 } | {
     kind: "stop";
-    workspacePath?: string;
+    target?: string;
 } | {
     kind: "invite";
-    workspacePath?: string;
+    target?: string;
 } | {
     kind: "logs";
-    workspacePath?: string;
+    target?: string;
     tail: number;
 } | {
     kind: "provider-setup";
-    workspacePath?: string;
+    target?: string;
 } | {
     kind: "provider-status";
-    workspacePath?: string;
+    target?: string;
 } | {
     kind: "doctor";
-    workspacePath?: string;
+    target?: string;
 };
 export type LaunchCliArgs = {
     command: "launch";
-    workspacePath: string;
+    target?: string;
     yes: boolean;
 };
-export declare function parseLaunchCliArgs(argv: readonly string[], cwd?: string): LaunchCliArgs;
+export declare function parseLaunchCliArgs(argv: readonly string[]): LaunchCliArgs;
 export declare function parseCliArgs(argv: readonly string[], cwd?: string): CliCommand;
 //# sourceMappingURL=args.d.ts.map

package/dist/server-shell/cli/args.js

@@ -6,13 +6,13 @@ function isHelpArg(arg) {
 function hasHelpArg(args) {
     return args.some((arg) => isHelpArg(arg));
 }
-export function parseLaunchCliArgs(argv, cwd = process.cwd()) {
+export function parseLaunchCliArgs(argv) {
     const args = [...argv];
     const command = args.shift();
     if (command !== "launch") {
-        throw new LaunchError("git_bootstrap_failed", "Expected command: launch", "Run `tutti launch [workspace_path] [--yes]`.");
+        throw new LaunchError("git_bootstrap_failed", "Expected command: launch", "Run `tutti launch [target] [--yes]`.");
     }
-    let workspacePath;
+    let target;
     let yes = false;
     for (const arg of args) {
         if (arg === "--yes") {
@@ -22,29 +22,29 @@ export function parseLaunchCliArgs(argv, cwd = process.cwd()) {
         if (arg.startsWith("--")) {
             throw new LaunchError("git_bootstrap_failed", `Unsupported option: ${arg}`, "Use only `--yes` with `tutti launch` in the MVP command surface.");
         }
-        if (workspacePath !== undefined) {
-            throw new LaunchError("git_bootstrap_failed", "Only one workspace_path argument is supported", "Run `tutti launch [workspace_path] [--yes]`.");
+        if (target !== undefined) {
+            throw new LaunchError("git_bootstrap_failed", "Only one target argument is supported", "Run `tutti launch [target] [--yes]`.");
         }
-        workspacePath = arg;
+        target = arg;
     }
     return {
         command: "launch",
-        workspacePath: resolve(cwd, workspacePath ?? "."),
+        ...(target === undefined ? {} : { target }),
         yes,
     };
 }
-function readOptionalWorkspace(args, cwd) {
-    let workspacePath;
+function readOptionalTarget(args) {
+    let target;
     for (const arg of args) {
         if (arg.startsWith("--")) {
             throw new LaunchError("git_bootstrap_failed", `Unsupported option: ${arg}`, "Run `tutti --help` to see supported commands.");
         }
-        if (workspacePath !== undefined) {
-            throw new LaunchError("git_bootstrap_failed", "Only one workspace_path argument is supported", "Run `tutti --help` to see supported commands.");
+        if (target !== undefined) {
+            throw new LaunchError("git_bootstrap_failed", "Only one target argument is supported", "Run `tutti --help` to see supported commands.");
         }
-        workspacePath = resolve(cwd, arg);
+        target = arg;
     }
-    return workspacePath;
+    return target;
 }
 export function parseCliArgs(argv, cwd = process.cwd()) {
     const args = [...argv];
@@ -59,7 +59,7 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
         return { kind: "version" };
     }
     if (command === "launch") {
-        let workspacePath;
+        let target;
         let yes = false;
         let foreground = false;
         for (const arg of args) {
@@ -77,12 +77,12 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
             if (arg.startsWith("--")) {
                 throw new LaunchError("git_bootstrap_failed", `Unsupported option: ${arg}`, "Use `tutti launch --help` to see supported launch options.");
             }
-            if (workspacePath !== undefined) {
-                throw new LaunchError("git_bootstrap_failed", "Only one workspace_path argument is supported", "Run `tutti launch [workspace_path] [--yes] [--foreground]`.");
+            if (target !== undefined) {
+                throw new LaunchError("git_bootstrap_failed", "Only one target argument is supported", "Run `tutti launch [target] [--yes] [--foreground]`.");
             }
-            workspacePath = resolve(cwd, arg);
+            target = arg;
         }
-        return { kind: "launch", workspacePath: workspacePath ?? resolve(cwd, "."), yes, foreground };
+        return { kind: "launch", ...(target === undefined ? {} : { target }), yes, foreground };
     }
     if (command === "internal") {
         const internalCommand = args.shift();
@@ -131,15 +131,15 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
         if (hasHelpArg(args)) {
             return { kind: "help", topic: "stop" };
         }
-        const workspacePath = readOptionalWorkspace(args, cwd);
-        return { kind: "stop", ...(workspacePath === undefined ? {} : { workspacePath }) };
+        const target = readOptionalTarget(args);
+        return { kind: "stop", ...(target === undefined ? {} : { target }) };
     }
     if (command === "invite") {
         if (hasHelpArg(args)) {
             return { kind: "help", topic: "invite" };
         }
-        const workspacePath = readOptionalWorkspace(args, cwd);
-        return { kind: "invite", ...(workspacePath === undefined ? {} : { workspacePath }) };
+        const target = readOptionalTarget(args);
+        return { kind: "invite", ...(target === undefined ? {} : { target }) };
     }
     if (command === "logs") {
         if (hasHelpArg(args)) {
@@ -153,7 +153,7 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
                 const value = args[index + 1];
                 const parsed = Number(value);
                 if (!Number.isInteger(parsed) || parsed <= 0) {
-                    throw new LaunchError("git_bootstrap_failed", "--tail requires a positive integer", "Run `tutti logs [workspace_path] --tail 120`.");
+                    throw new LaunchError("git_bootstrap_failed", "--tail requires a positive integer", "Run `tutti logs [target] --tail 120`.");
                 }
                 tail = parsed;
                 index += 1;
@@ -162,8 +162,8 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
                 positional.push(arg ?? "");
             }
         }
-        const workspacePath = readOptionalWorkspace(positional, cwd);
-        return { kind: "logs", tail, ...(workspacePath === undefined ? {} : { workspacePath }) };
+        const target = readOptionalTarget(positional);
+        return { kind: "logs", tail, ...(target === undefined ? {} : { target }) };
     }
     if (command === "provider") {
         const providerCommand = args.shift();
@@ -174,15 +174,15 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
             if (hasHelpArg(args)) {
                 return { kind: "help", topic: "provider" };
             }
-            const workspacePath = readOptionalWorkspace(args, cwd);
-            return { kind: "provider-setup", ...(workspacePath === undefined ? {} : { workspacePath }) };
+            const target = readOptionalTarget(args);
+            return { kind: "provider-setup", ...(target === undefined ? {} : { target }) };
         }
         if (providerCommand === "status") {
             if (hasHelpArg(args)) {
                 return { kind: "help", topic: "provider" };
             }
-            const workspacePath = readOptionalWorkspace(args, cwd);
-            return { kind: "provider-status", ...(workspacePath === undefined ? {} : { workspacePath }) };
+            const target = readOptionalTarget(args);
+            return { kind: "provider-status", ...(target === undefined ? {} : { target }) };
         }
         return { kind: "help", topic: "provider" };
     }
@@ -190,8 +190,8 @@ export function parseCliArgs(argv, cwd = process.cwd()) {
         if (hasHelpArg(args)) {
             return { kind: "help", topic: "doctor" };
         }
-        const workspacePath = readOptionalWorkspace(args, cwd);
-        return { kind: "doctor", ...(workspacePath === undefined ? {} : { workspacePath }) };
+        const target = readOptionalTarget(args);
+        return { kind: "doctor", ...(target === undefined ? {} : { target }) };
     }
     throw new LaunchError("git_bootstrap_failed", `Unsupported command: ${command}`, "Run `tutti --help` to see supported commands.");
 }

package/dist/server-shell/cli/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { formatCliError } from "./errors.js";
+import { formatCliError, formatCliErrorReason } from "./errors.js";
 import { parseCliArgs } from "./args.js";
 import { runBackgroundLaunchCommand, runForegroundLaunchCommand, runInternalHostRunCommand, } from "./launch-command.js";
 import { resolveExistingProjectContext } from "./project-resolver.js";
@@ -7,14 +7,14 @@ import { runProviderSetupTui } from "./provider-tui.js";
 import { runInviteCommand, runLogsCommand, runProviderStatusCommand, runPsManageCommand, runPsCommand, runStopCommand, } from "./runtime-commands.js";
 import { readCliVersion } from "./version.js";
 const HELP_TEXT = `Usage:
-  tutti launch [workspace_path] [--yes] [--foreground]
+  tutti launch [target] [--yes] [--foreground]
   tutti ps [--manage]
-  tutti invite [workspace_path]
-  tutti stop [workspace_path]
-  tutti logs [workspace_path] [--tail 120]
-  tutti provider setup [workspace_path]
-  tutti provider status [workspace_path]
-  tutti doctor [workspace_path]
+  tutti invite [target]
+  tutti stop [target]
+  tutti logs [target] [--tail 120]
+  tutti provider setup [target]
+  tutti provider status [target]
+  tutti doctor [target]
 
 Options:
   -h, --help      Show help.
@@ -25,7 +25,7 @@ Notes:
   provider setup stores credentials in the machine-local Tutti provider store.
 `;
 const LAUNCH_HELP_TEXT = `Usage:
-  tutti launch [workspace_path] [--yes] [--foreground]
+  tutti launch [target] [--yes] [--foreground]
 
 Starts or reconnects a Tutti project host.
 
@@ -34,8 +34,8 @@ Options:
   --foreground   Keep the host attached to this terminal for diagnostics.
 `;
 const PROVIDER_HELP_TEXT = `Usage:
-  tutti provider setup [workspace_path]
-  tutti provider status [workspace_path]
+  tutti provider setup [target]
+  tutti provider status [target]
 
 Commands:
   setup    Configure or replace the OpenAI-compatible provider credential.
@@ -48,22 +48,22 @@ Options:
   --manage   Open the keyboard project manager.
 `;
 const INVITE_HELP_TEXT = `Usage:
-  tutti invite [workspace_path]
+  tutti invite [target]
 
 Rotates a fresh join link and renders it as a terminal QR code.
 `;
 const STOP_HELP_TEXT = `Usage:
-  tutti stop [workspace_path]
+  tutti stop [target]
 
 Stops the background Tutti host for a project.
 `;
 const LOGS_HELP_TEXT = `Usage:
-  tutti logs [workspace_path] [--tail 120]
+  tutti logs [target] [--tail 120]
 
 Shows recent host log lines from the machine-local Tutti log file.
 `;
 const DOCTOR_HELP_TEXT = `Usage:
-  tutti doctor [workspace_path]
+  tutti doctor [target]
 
 Prints local runtime, project, provider, and host diagnostics.
 `;
@@ -91,9 +91,9 @@ function helpForTopic(topic) {
     }
     return HELP_TEXT;
 }
-async function runProviderSetupCommand(workspacePath) {
+async function runProviderSetupCommand(target) {
     const project = resolveExistingProjectContext({
-        ...(workspacePath === undefined ? {} : { workspacePath }),
+        ...(target === undefined ? {} : { target }),
     });
     const result = await runProviderSetupTui({
         tuttiHome: project.tutti_home,
@@ -102,20 +102,19 @@ async function runProviderSetupCommand(workspacePath) {
     process.stdout.write([
         "",
         "Provider configured.",
-        `Base URL: ${result.base_url}`,
         `Model: ${result.default_model}`,
         `Key: ${result.redacted_key}`,
         `Validated: ${result.validated_at}`,
     ].join("\n"));
     process.stdout.write("\n");
 }
-function runDoctorCommand(workspacePath) {
+function runDoctorCommand(target) {
     const checks = [];
     checks.push(`Node: ${process.version}`);
     checks.push(`Tutti: ${readCliVersion()}`);
     try {
         const project = resolveExistingProjectContext({
-            ...(workspacePath === undefined ? {} : { workspacePath }),
+            ...(target === undefined ? {} : { target }),
         });
         checks.push(`Project: ${project.display_name}`);
         checks.push(`Project ID: ${project.project_id}`);
@@ -123,7 +122,8 @@ function runDoctorCommand(workspacePath) {
         checks.push(`Host: ${project.runtime_endpoint === null ? "not running" : project.runtime_endpoint.base_url}`);
     }
     catch (error) {
-        checks.push(`Project: unavailable (${error instanceof Error ? error.message : "unknown"})`);
+        checks.push("Project: unavailable");
+        checks.push(`Project detail: ${formatCliErrorReason(error)}`);
     }
     process.stdout.write(`${checks.join("\n")}\n`);
 }
@@ -156,22 +156,22 @@ try {
             }
             break;
         case "stop":
-            process.stdout.write(`${await runStopCommand(command.workspacePath)}\n`);
+            process.stdout.write(`${await runStopCommand(command.target)}\n`);
             break;
         case "invite":
-            process.stdout.write(`${await runInviteCommand(command.workspacePath)}\n`);
+            process.stdout.write(`${await runInviteCommand(command.target)}\n`);
             break;
         case "logs":
-            process.stdout.write(`${runLogsCommand(command.workspacePath, command.tail)}\n`);
+            process.stdout.write(`${runLogsCommand(command.target, command.tail)}\n`);
             break;
         case "provider-setup":
-            await runProviderSetupCommand(command.workspacePath);
+            await runProviderSetupCommand(command.target);
             break;
         case "provider-status":
-            process.stdout.write(`${runProviderStatusCommand(command.workspacePath)}\n`);
+            process.stdout.write(`${runProviderStatusCommand(command.target)}\n`);
             break;
         case "doctor":
-            runDoctorCommand(command.workspacePath);
+            runDoctorCommand(command.target);
             break;
     }
 }

package/dist/server-shell/cli/errors.d.ts

@@ -1,4 +1,4 @@
-export type LaunchErrorCode = "unsafe_project_root" | "unsupported_tutti_schema" | "project_identity_conflict" | "git_bootstrap_failed" | "sensitive_file_detected" | "relay_unavailable" | "relay_registration_failed" | "provider_configuration_required" | "provider_setup_cancelled" | "provider_validation_failed" | "store_migration_failed" | "existing_server_unhealthy" | "takeover_rejected" | "takeover_failed" | "port_unavailable";
+export type LaunchErrorCode = "unsafe_project_root" | "unsupported_tutti_schema" | "project_identity_conflict" | "git_bootstrap_failed" | "sensitive_file_detected" | "relay_unavailable" | "relay_registration_failed" | "host_not_running" | "project_target_ambiguous" | "project_target_not_found" | "provider_configuration_required" | "provider_setup_cancelled" | "provider_validation_failed" | "store_migration_failed" | "existing_server_unhealthy" | "takeover_rejected" | "takeover_failed" | "port_unavailable";
 export declare class LaunchError extends Error {
     readonly code: LaunchErrorCode;
     readonly next: string;
@@ -7,4 +7,5 @@ export declare class LaunchError extends Error {
 }
 export declare function formatLaunchError(error: unknown): string;
 export declare function formatCliError(error: unknown): string;
+export declare function formatCliErrorReason(error: unknown): string;
 //# sourceMappingURL=errors.d.ts.map

package/dist/server-shell/cli/errors.js

@@ -1,4 +1,4 @@
-import { redactError, redactText } from "@tutti/shared/utils";
+import { redactAndTruncateText, redactError, redactText } from "@tutti/shared/utils";
 export class LaunchError extends Error {
     code;
     next;
@@ -20,24 +20,22 @@ export function formatLaunchError(error) {
             "Tutti launch failed",
             "",
             `Code: ${error.code}`,
-            `Reason: ${redactText(error.message)}`,
+            `Reason: ${formatBoundedText(error.message)}`,
         ];
         const detailLines = Object.entries(error.details)
             .filter(([, value]) => value !== undefined)
-            .map(([key, value]) => `Detail ${key}: ${redactText(formatDetailValue(value))}`);
+            .map(([key, value]) => `Detail ${key}: ${formatBoundedDetail(value)}`);
         if (detailLines.length > 0) {
             lines.push(...detailLines);
         }
         lines.push(`Next: ${redactText(error.next)}`);
         return lines.join("\n");
     }
-    const redactedError = redactError(error);
-    const reason = typeof redactedError === "string" ? redactedError : JSON.stringify(redactedError);
     return [
         "Tutti launch failed",
         "",
         "Code: internal_error",
-        `Reason: ${reason ?? "Unknown error"}`,
+        `Reason: ${formatUnknownErrorReason(error)}`,
         "Next: Retry after checking the local debug logs.",
     ].join("\n");
 }
@@ -46,26 +44,71 @@ export function formatCliError(error) {
         if (error.code === "provider_setup_cancelled") {
             return ["Tutti command cancelled", "", `Reason: ${redactText(error.message)}`].join("\n");
         }
-        const lines = ["Tutti command failed", "", `Code: ${error.code}`, `Reason: ${redactText(error.message)}`];
+        const lines = ["Tutti command failed", "", `Code: ${error.code}`, `Reason: ${formatBoundedText(error.message)}`];
         const detailLines = Object.entries(error.details)
             .filter(([, value]) => value !== undefined)
-            .map(([key, value]) => `Detail ${key}: ${redactText(formatDetailValue(value))}`);
+            .map(([key, value]) => `Detail ${key}: ${formatBoundedDetail(value)}`);
         if (detailLines.length > 0) {
             lines.push(...detailLines);
         }
         lines.push(`Next: ${redactText(error.next)}`);
         return lines.join("\n");
     }
-    const redactedError = redactError(error);
-    const reason = typeof redactedError === "string" ? redactedError : JSON.stringify(redactedError);
     return [
         "Tutti command failed",
         "",
         "Code: internal_error",
-        `Reason: ${reason ?? "Unknown error"}`,
+        `Reason: ${formatUnknownErrorReason(error)}`,
         "Next: Retry after checking the local debug logs.",
     ].join("\n");
 }
+const MAX_REASON_LENGTH = 320;
+const MAX_DETAIL_LENGTH = 720;
+function formatBoundedText(value) {
+    return redactAndTruncateText(value, MAX_REASON_LENGTH);
+}
+function formatBoundedDetail(value) {
+    return redactAndTruncateText(formatDetailValue(value), MAX_DETAIL_LENGTH);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function formatCliErrorReason(error) {
+    const redactedError = redactError(error);
+    if (typeof redactedError === "string" && redactedError.trim() !== "") {
+        return formatBoundedText(redactedError);
+    }
+    if (isRecord(redactedError)) {
+        const message = redactedError.message;
+        if (typeof message === "string" && message.trim() !== "") {
+            return formatBoundedText(message);
+        }
+        const name = redactedError.name;
+        if (typeof name === "string" && name.trim() !== "") {
+            return formatBoundedText(name);
+        }
+    }
+    return "Unexpected error.";
+}
+function formatUnknownErrorReason(error) {
+    return formatCliErrorReason(error);
+}
+function stripStackFields(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => stripStackFields(entry));
+    }
+    if (isRecord(value)) {
+        const stripped = {};
+        for (const [key, nested] of Object.entries(value)) {
+            if (key.toLowerCase() === "stack") {
+                continue;
+            }
+            stripped[key] = stripStackFields(nested);
+        }
+        return stripped;
+    }
+    return value;
+}
 function formatDetailValue(value) {
     if (Array.isArray(value)) {
         return value.map((entry) => formatDetailValue(entry)).join(", ");
@@ -76,6 +119,6 @@ function formatDetailValue(value) {
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
         return String(value);
     }
-    return JSON.stringify(value) ?? "undefined";
+    return JSON.stringify(stripStackFields(value)) ?? "undefined";
 }
 //# sourceMappingURL=errors.js.map

package/dist/server-shell/cli/host-lifecycle.js

@@ -10,6 +10,7 @@ import { HOST_SERVER_VERSION, startForegroundHostServer, } from "./host-server-r
 import { deleteMachineRuntimeEndpoint, readHostRegistrationSecret, readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
 import { prepareLaunchProject, resolveLaunchLocalContext, } from "./launch.js";
 import { registerHostWithRelay, relayErrorToLaunchError, } from "./relay-registration.js";
+import { formatJoinLinkValidity } from "./terminal-qr.js";
 export { createRuntimeEndpointProbe } from "./host-runtime-endpoint.js";
 const DEFAULT_SHUTDOWN_WAIT_MS = 2_000;
 const OSC8_START = "\u001B]8;;";
@@ -277,6 +278,12 @@ export function formatLaunchLifecycleResult(result, options = {}) {
     }
     if (summary.relay?.join_url !== undefined) {
         fields.push(urlLine("Join URL", summary.relay.join_url, options));
+        fields.push(formatJoinLinkValidity({
+            ...(summary.relay.join_token_expires_at === undefined
+                ? {}
+                : { expiresAt: summary.relay.join_token_expires_at }),
+            reusable: summary.relay.join_token_reusable,
+        }));
     }
     else if (summary.relay?.join_url_visibility === "not_recoverable") {
         fields.push("Join URL: not recoverable; rotate a fresh invite from the host.");

package/dist/server-shell/cli/launch-command.d.ts

@@ -1,7 +1,7 @@
 import type { LaunchConfirmationRequest } from "./git-bootstrap.js";
 export declare function confirmFromTty(request: LaunchConfirmationRequest): Promise<boolean>;
 export declare function runForegroundLaunchCommand(options: {
-    workspacePath: string;
+    target?: string;
     yes: boolean;
 }): Promise<void>;
 export declare function runInternalHostRunCommand(options: {
@@ -9,7 +9,7 @@ export declare function runInternalHostRunCommand(options: {
     yes: boolean;
 }): Promise<void>;
 export declare function runBackgroundLaunchCommand(options: {
-    workspacePath: string;
+    target?: string;
     yes: boolean;
 }): Promise<void>;
 //# sourceMappingURL=launch-command.d.ts.map