@xfey/tutti 0.1.11 → 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

@@ -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,
@@ -108,13 +108,13 @@ async function runProviderSetupCommand(workspacePath) {
     ].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}`);
@@ -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" | "host_not_running" | "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;

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

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

@@ -2,7 +2,8 @@ import { createInterface } from "node:readline/promises";
 import { formatLaunchLifecycleResult, startLaunchProject, waitForForegroundHostShutdown } from "./host-lifecycle.js";
 import { prepareLaunchProject } from "./launch.js";
 import { spawnDetachedHost, waitForManagedHostReady } from "./managed-host.js";
-import { renderTerminalQr } from "./terminal-qr.js";
+import { resolveLaunchWorkspacePath } from "./project-resolver.js";
+import { formatJoinLinkValidity, renderTerminalQr } from "./terminal-qr.js";
 import { renderTuttiTerminalLogo } from "./terminal-logo.js";
 import { runProviderSetupTui } from "./provider-tui.js";
 import { LaunchError } from "./errors.js";
@@ -45,6 +46,14 @@ function renderCompletionPage(options) {
         "Tutti is running in the background.",
         "",
         `Join URL: ${options.joinUrl}`,
+        formatJoinLinkValidity({
+            ...(options.joinTokenExpiresAt === undefined
+                ? {}
+                : { expiresAt: options.joinTokenExpiresAt }),
+            ...(options.joinTokenReusable === undefined
+                ? {}
+                : { reusable: options.joinTokenReusable }),
+        }),
         "",
         renderTerminalQr(options.joinUrl),
         "",
@@ -64,8 +73,11 @@ async function ensureProviderConfigured(preparation) {
     });
 }
 export async function runForegroundLaunchCommand(options) {
+    const workspacePath = resolveLaunchWorkspacePath({
+        ...(options.target === undefined ? {} : { target: options.target }),
+    });
     const result = await startLaunchProject({
-        workspacePath: options.workspacePath,
+        workspacePath,
         yes: options.yes,
         confirm: confirmFromTty,
     });
@@ -84,8 +96,11 @@ export async function runInternalHostRunCommand(options) {
     }
 }
 export async function runBackgroundLaunchCommand(options) {
+    const workspacePath = resolveLaunchWorkspacePath({
+        ...(options.target === undefined ? {} : { target: options.target }),
+    });
     const preparation = await prepareLaunchProject({
-        workspacePath: options.workspacePath,
+        workspacePath,
         yes: options.yes,
         confirm: confirmFromTty,
     });
@@ -103,6 +118,12 @@ export async function runBackgroundLaunchCommand(options) {
     }
     process.stdout.write(`${renderCompletionPage({
         joinUrl: ready.join_url,
+        ...(ready.join_token_expires_at === undefined
+            ? {}
+            : { joinTokenExpiresAt: ready.join_token_expires_at }),
+        ...(ready.join_token_reusable === undefined
+            ? {}
+            : { joinTokenReusable: ready.join_token_reusable }),
     })}\n`);
     await waitForEnter();
 }

package/dist/server-shell/cli/managed-host.d.ts

@@ -4,6 +4,8 @@ import type { ProjectId } from "@tutti/shared/ids";
 export type ManagedHostReadyResult = {
     endpoint: MachineRuntimeEndpointRecord;
     join_url?: string;
+    join_token_expires_at?: string;
+    join_token_reusable?: boolean;
 };
 export declare function spawnDetachedHost(options: {
     workspaceRoot: string;

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

@@ -74,6 +74,12 @@ export async function waitForManagedHostReady(options) {
                 return {
                     endpoint,
                     join_url: status.relay.join_url,
+                    ...(status.relay.join_token_expires_at === undefined
+                        ? {}
+                        : { join_token_expires_at: status.relay.join_token_expires_at }),
+                    ...(status.relay.join_token_reusable === undefined
+                        ? {}
+                        : { join_token_reusable: status.relay.join_token_reusable }),
                 };
             }
             lastReason = "host is running but Relay invite is not visible yet";

package/dist/server-shell/cli/project-resolver.d.ts

@@ -11,7 +11,13 @@ export type ExistingProjectContext = {
     provider_config: OpenAiProviderConfigProjection;
     provider_base_url?: string;
 };
+export declare function resolveLaunchWorkspacePath(options: {
+    target?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
 export declare function resolveExistingProjectContext(options: {
+    target?: string;
     workspacePath?: string;
     cwd?: string;
     env?: NodeJS.ProcessEnv;