@qduc/term2 0.27.0 → 0.29.0

package/dist/cli.js

@@ -1,10 +1,7 @@
 #!/usr/bin/env node
 import './env-setup.js';
-import React from 'react';
-import { render } from 'ink';
 import meow from 'meow';
-import App from './app.js';
-import { getInkRenderOptions } from './utils/ink-render-options.js';
+import { createRequire } from 'node:module';
 import { AgentClient } from './lib/agent-client.js';
 import { ConversationService } from './services/conversation/conversation-service.js';
 import { SettingsService, buildEnvOverrides } from './services/settings/settings-service.js';
@@ -16,11 +13,13 @@ import { HistoryService } from './services/history-service.js';
 import { SSHService } from './services/ssh-service.js';
 import { ExecutionContext } from './services/execution-context.js';
 import { resolveSSHHost } from './utils/ssh-config-parser.js';
+import { resolveSettingsDirectory } from './services/settings/settings-path.js';
 import { createUsageAccumulator, formatSessionUsageBreakdown } from './utils/ai/token-usage.js';
 import { createSessionCostAccumulator, formatModelUsageBreakdown, formatUsdMicros, } from './services/cost/model-cost.js';
 import { buildProjectFolderTitle, setTerminalTitle } from './utils/output/terminal-title.js';
-import { generateId, collectOrphanedDeltaSidecars, getConversationsDir, getResumeCommand, loadConversationForProject, loadLastConversation, forkConversation, isConversationLocked, deleteConversation, hasConversationContent, } from './services/conversation/conversation-persistence.js';
+import { generateId, collectOrphanedDeltaSidecars, getConversationsDir, getConversationLockPath, getResumeCommand, loadConversationForProject, loadLastConversation, forkConversation, isConversationLocked, deleteConversation, hasConversationContent, } from './services/conversation/conversation-persistence.js';
 import { listRecentConversations } from './services/conversation/recent-conversations.js';
+import { rotateSessionLog } from './services/conversation/session-log-lifecycle.js';
 import { formatResumeList } from './utils/resume-list.js';
 import { killLiveShellChildren } from './utils/shell/execute-shell.js';
 import { createConversationLogWriter, LockConflictError } from './services/logging/conversation-log-writer.js';
@@ -45,6 +44,29 @@ import { McpOAuthStore } from './services/mcp/mcp-oauth-store.js';
 import { McpConfigController } from './services/mcp/mcp-config-controller.js';
 import { MemoryCapabilityBuilder } from './services/memory/memory-capabilities.js';
 import { AutomaticMemoryCanary } from './services/memory/automatic-memory-canary.js';
+import { ControlSocketServer, isControlSocketName } from './services/control-socket/control-socket.js';
+import { runControlCommand } from './services/control-socket/control-command.js';
+import { createDurableGoal } from './services/conversation/durable-goal.js';
+const controlArgv = [];
+let controlSocketRequested = false;
+let controlSocketName;
+let controlSocketNameRejected = false;
+for (const arg of process.argv.slice(2)) {
+    if (arg === '--control-socket') {
+        controlSocketRequested = true;
+        controlSocketName ??= String(process.pid);
+    }
+    else if (arg.startsWith('--control-socket=')) {
+        controlSocketRequested = true;
+        const name = arg.slice('--control-socket='.length);
+        controlSocketName = name;
+        if (!isControlSocketName(name))
+            controlSocketNameRejected = true;
+    }
+    else {
+        controlArgv.push(arg);
+    }
+}
 const sessionUsageAccumulator = createUsageAccumulator();
 const subagentUsageAccumulator = createUsageAccumulator();
 const sessionCostAccumulator = createSessionCostAccumulator();
@@ -72,11 +94,20 @@ const printUsageOnce = () => {
         return;
     usagePrinted = true;
     printUsage();
+    if (effectiveSessionId && effectiveHasConversationContent && !sessionSummaryPrinted) {
+        sessionSummaryPrinted = true;
+        // Only reachable once the session id exists, after SSH setup has run.
+        const resumeCommand = getResumeCommand(effectiveSessionId, sshFlag, sshInfo?.remoteDir, cli.flags.sshPort);
+        process.stdout.write(`\nSession: ${effectiveSessionId}\nTo resume this conversation: ${resumeCommand}\n`);
+    }
 };
 let activeLogWriter = null;
 let activeSessionBrowser = null;
 let activeMcpManager = null;
+let activeControlSocketServer = null;
 let effectiveSessionId;
+let effectiveHasConversationContent = false;
+let sessionSummaryPrinted = false;
 // Global Ctrl+C handler for immediate exit paths outside Ink's input handling.
 process.on('SIGINT', () => {
     if (process.stdout.isTTY) {
@@ -86,6 +117,7 @@ process.on('SIGINT', () => {
         activeLogWriter ? activeLogWriter.flush() : Promise.resolve(),
         activeSessionBrowser ? activeSessionBrowser.close() : Promise.resolve(),
         activeMcpManager ? activeMcpManager.close() : Promise.resolve(),
+        activeControlSocketServer ? activeControlSocketServer.close() : Promise.resolve(),
     ]).finally(() => {
         printUsageOnce();
         process.exit(130);
@@ -99,6 +131,7 @@ process.on('SIGTERM', () => {
         activeLogWriter ? activeLogWriter.flush() : Promise.resolve(),
         activeSessionBrowser ? activeSessionBrowser.close() : Promise.resolve(),
         activeMcpManager ? activeMcpManager.close() : Promise.resolve(),
+        activeControlSocketServer ? activeControlSocketServer.close() : Promise.resolve(),
     ]).finally(() => {
         process.exit(143);
     });
@@ -138,15 +171,36 @@ process.on('exit', () => {
         /* ignore */
     }
 });
+const require = createRequire(import.meta.url);
+let reportedVersion;
+try {
+    const buildInfo = require('./build-info.json');
+    if (buildInfo.version)
+        reportedVersion = buildInfo.version;
+}
+catch {
+    // Source checkouts and older/test builds have no generated build identity.
+}
 const cli = meow(`
+    Everyday usage
+      $ term2
+      $ term2 "explain this function"
+      $ term2 --resume
+      $ term2 --resume <conversation-id>
+      $ term2 --help
+
     Usage
       $ term2 [options] [prompt...]
       $ term2 [options] --resume [conversation-id|ls]
 
+    In a chat, type / to see available commands.
+
     Options
       -m, --model <model>                  Model pattern or ID, supports provider/id and optional :<thinking>
       -p, --provider <provider>            Override the configured provider (e.g. openai, openrouter)
       -r, --reasoning <effort>             Set reasoning effort (default, none, minimal, low, medium, high, xhigh)
+          --goal <text>                    Persist a user-authored session outcome (max 2,000 characters)
+          --goal-criteria <text>            Optional success criteria (max 2,000 characters; requires --goal)
       -l, --lite                           Start in lite mode (minimal context, session-only)
           --auto-approve                   Allow tool execution for a non-interactive prompt
       -q, --quiet                          Suppress non-error diagnostics on stderr in non-interactive mode
@@ -155,15 +209,19 @@ const cli = meow(`
           --ssh <user@host>                Enable SSH mode for a remote host
           --remote-dir <path>              Remote working directory (required for non-lite SSH sessions)
           --ssh-port <port>                SSH port (default: 22)
+          --control-socket[=<name>]        Enable a local socket for the interactive TUI
           --grok-login                     Log in to Grok in a browser (OAuth) and exit
           --codex-login                    Log in to Codex/ChatGPT in a browser (OAuth) and exit
           --list-models [search]           Print available models grouped by provider, filtered by an optional search term
           --refresh                        With --list-models, bypass the model catalog cache and re-fetch before listing
       -R, --resume [conversation-id|ls]    Resume the last conversation, a specific ID, or list recent conversations
-          --fork                            Fork the resumed conversation into a new session (requires --resume)
+          --fork                           Fork the resumed conversation into a new session (requires --resume)
       -h, --help                           Show help
       -v, --version                        Show version
 
+    Settings
+      Settings file: ${path.join(resolveSettingsDirectory(), 'settings.json')}
+
     Notes
       A prompt passed on the command line runs non-interactively. Tool execution is disabled by default;
       use --auto-approve to allow tools to run without interactive confirmation.
@@ -171,10 +229,10 @@ const cli = meow(`
       -m/--model with no value (bare --model/-m, or followed only by another flag) opens an
       interactive picker in a TTY session with no prompt; the same picker also opens for an
       ambiguous or unmatched pattern. Elsewhere (no TTY, --json, or a prompt on the line) it is a
-      no-op. A value right after -m/--model is always the model, exactly as before.
+      no-op. If no model is selected, term2 starts with the configured default.
 
     Gateway launcher (term2 serve)
-      Runs the private web gateway for the ChatForge BFF until SIGINT/SIGTERM.
+      Runs the local web gateway until SIGINT/SIGTERM.
 
       $ term2 serve --local-owner <userId> [--state-dir <dir>] [--socket <path>]
           [--listen <host:port> --tls-cert <pem> --tls-key <pem>] [--allow-remote]
@@ -199,9 +257,7 @@ const cli = meow(`
       and --auto-approve is rejected. --model is resolved against the model catalog
       non-interactively, so it needs an exact model id or <provider>/<model>.
 
-    Examples
-      $ term2
-      $ term2 "explain this function"
+    More examples
       $ term2 --model gpt-5.4 --provider openai
       $ term2 --model
       $ term2 --lite
@@ -220,13 +276,19 @@ const cli = meow(`
       $ term2 --list-models --refresh
       $ term2 --ssh user@host --remote-dir /path/to/project
       $ term2 --ssh user@host --remote-dir /path/to/project --ssh-port 2222
+      $ term2 --control-socket=worker-1
+      $ term2 control status worker-1 --json
   `, {
+    ...(reportedVersion ? { version: reportedVersion } : {}),
     importMeta: import.meta,
+    argv: controlArgv,
     flags: {
         model: {
             type: 'string',
             alias: 'm',
         },
+        help: { type: 'boolean', alias: 'h', default: false },
+        version: { type: 'boolean', alias: 'v', default: false },
         provider: {
             type: 'string',
             alias: 'p',
@@ -235,6 +297,8 @@ const cli = meow(`
             type: 'string',
             alias: 'r',
         },
+        goal: { type: 'string' },
+        goalCriteria: { type: 'string' },
         lite: {
             type: 'boolean',
             alias: 'l',
@@ -293,7 +357,12 @@ const cli = meow(`
             default: false,
         },
     },
+    allowUnknownFlags: controlArgv[0] === 'control' || process.argv[2] === 'serve' || process.argv[2] === 'acp',
 });
+if (cli.input[0] === 'control') {
+    const exitCode = await runControlCommand(controlArgv.slice(1), process.stdout, process.stderr);
+    process.exit(exitCode);
+}
 function oauthLoginIo(providerLabel) {
     return {
         pasteInput: process.stdin.isTTY ? process.stdin : undefined,
@@ -425,6 +494,18 @@ if (forkRequested && !resumeRequested) {
 }
 const positionalPrompt = resumeRequested ? '' : cli.input.join(' ').trim();
 const hasPositionalPrompt = positionalPrompt.length > 0;
+let launchGoal;
+try {
+    if (cli.flags.goalCriteria !== undefined && cli.flags.goal === undefined) {
+        throw new Error('--goal-criteria requires --goal.');
+    }
+    if (cli.flags.goal !== undefined)
+        launchGoal = createDurableGoal(cli.flags.goal, cli.flags.goalCriteria);
+}
+catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+}
 // If the user passed an explicit empty prompt (e.g. `term2 ""`), show help.
 if (!resumeRequested && cli.input.length > 0 && !hasPositionalPrompt) {
     cli.showHelp(0);
@@ -496,6 +577,7 @@ if (resumeRequested) {
         }
         if (result.status === 'project_mismatch') {
             console.error(`Error: Conversation ${resumeTarget} belongs to a different project path (${result.conversation.projectPath ?? 'unknown'}).`);
+            console.error(`Resume it from that project directory with: term2 --resume ${resumeTarget}`);
             console.error(`Current project path: ${resumeProjectPath ?? 'unknown'}`);
             if (result.conversation.sshHost || expectedSshHost) {
                 console.error(`Conversation SSH Host: ${result.conversation.sshHost ?? 'none'}`);
@@ -553,9 +635,6 @@ if (resumedConversation) {
         };
     }
 }
-if (modelFlag) {
-    cliOverrides.agent = { ...cliOverrides.agent, model: modelFlag };
-}
 if (providerFlag) {
     cliOverrides.agent = { ...cliOverrides.agent, provider: providerFlag };
 }
@@ -595,12 +674,12 @@ if (modelFlagGivenWithoutValue && canUseInteractiveModelPicker) {
     const { runModelPickerHost } = await import('./services/models/model-picker-host.js');
     const picked = await runModelPickerHost({ settingsService: settings, loggingService: logger });
     if (picked.status === 'cancelled') {
-        console.error('Cancelled.');
-        process.exit(1);
+        // Escape keeps the configured (or resumed) model and continues startup.
+    }
+    else {
+        settings.set('agent.model', picked.selection.modelId, { persist: false });
+        settings.set('agent.provider', picked.selection.provider, { persist: false });
     }
-    // Same session-only override contract as the --model <pattern> path below.
-    settings.set('agent.model', picked.selection.modelId, { persist: false });
-    settings.set('agent.provider', picked.selection.provider, { persist: false });
 }
 if (modelFlag) {
     const { resolveModelFlag } = await import('./services/models/model-resolution.js');
@@ -630,24 +709,29 @@ if (modelFlag) {
         process.exit(1);
     }
     if (resolution.status === 'cancelled') {
-        console.error('Cancelled.');
-        process.exit(1);
-    }
-    // Surfaces provider catalogs that failed to load while resolution still
-    // proceeded, so a partial outage never silently narrows what was matched.
-    if ('warnings' in resolution && resolution.warnings) {
-        for (const warning of resolution.warnings) {
-            console.error(warning);
+        if (!canUseInteractiveModelPicker) {
+            console.error('Cancelled.');
+            process.exit(1);
         }
+        // Escape returns to the configured default model instead of aborting startup.
     }
-    // --model is a per-session override like every other CLI flag; it must not
-    // rewrite the user's persisted defaults (set() persists by default).
-    settings.set('agent.model', resolution.modelId, { persist: false });
-    if (resolution.provider) {
-        settings.set('agent.provider', resolution.provider, { persist: false });
-    }
-    if (resolution.reasoningEffort && !validatedReasoningEffort) {
-        settings.set('agent.reasoningEffort', resolution.reasoningEffort, { persist: false });
+    else {
+        // Surfaces provider catalogs that failed to load while resolution still
+        // proceeded, so a partial outage never silently narrows what was matched.
+        if ('warnings' in resolution && resolution.warnings) {
+            for (const warning of resolution.warnings) {
+                console.error(warning);
+            }
+        }
+        // --model is a per-session override like every other CLI flag; it must not
+        // rewrite the user's persisted defaults (set() persists by default).
+        settings.set('agent.model', resolution.modelId, { persist: false });
+        if (resolution.provider) {
+            settings.set('agent.provider', resolution.provider, { persist: false });
+        }
+        if (resolution.reasoningEffort && !validatedReasoningEffort) {
+            settings.set('agent.reasoningEffort', resolution.reasoningEffort, { persist: false });
+        }
     }
 }
 // Fresh sessions honor --lite/non-interactive defaults. Resumed sessions keep
@@ -845,6 +929,9 @@ const localHookRuntime = createRootHookRuntime({
 });
 const { hookService } = localHookRuntime;
 await hookService.initialize();
+// Shared by the owned root client and the interactive goal command callback.
+// Mutations become visible to later provider requests only after the event append succeeds.
+const currentGoalState = { current: resumedConversation?.goal };
 const sessionClientFactory = createOwnedSessionClientFactory(settings, (_sessionId, toolOwnership, postExecutePauseCapability, access, continuationProjectionMode, _continuity, requestCapture, toolLifecycle, backgroundShellRegistry, allowBackgroundShell, backgroundShellOutput, allowAskUser) => {
     const agentClient = new AgentClient({
         model: settings.get('agent.model'),
@@ -854,6 +941,7 @@ const sessionClientFactory = createOwnedSessionClientFactory(settings, (_session
         deps: {
             logger: logger,
             settings: settings,
+            getGoal: () => currentGoalState.current,
             executionContext: executionContext,
             sessionContextService,
             skillsService,
@@ -889,6 +977,10 @@ if (hasPositionalPrompt) {
         hookLifecycle: hookService,
         mcpAllowlist: mcpConfig.nonInteractiveAllow,
         mcpToolSource: mcpManager,
+        initialGoal: launchGoal,
+        onGoalPersisted: (goal) => {
+            currentGoalState.current = goal;
+        },
     });
     process.exit(exitCode);
 }
@@ -898,7 +990,6 @@ effectiveSessionId = generateId();
 let effectiveCreatedAt = new Date().toISOString();
 let initialMessages = [];
 let restoredStaticMessageIds = [];
-let effectiveHasConversationContent = false;
 if (resumedConversation) {
     effectiveSessionId = resumedConversation.id;
     effectiveCreatedAt = resumedConversation.createdAt;
@@ -928,7 +1019,7 @@ if (!forkRequested) {
     const lockInfo = isConversationLocked(effectiveSessionId);
     if (lockInfo !== null) {
         if (lockInfo.status === 'corrupt') {
-            console.error(`Conversation ${effectiveSessionId} has a corrupt lockfile.\n` +
+            console.error(`Conversation ${effectiveSessionId} has a corrupt lockfile at ${getConversationLockPath(effectiveSessionId)}.\n` +
                 `- If another terminal still has it open, close that one first.\n` +
                 `- Otherwise delete the lockfile manually, or fork into a new\n` +
                 `  conversation that branches from the same state:\n` +
@@ -1002,7 +1093,10 @@ const logWriterDir = getConversationsDir();
 collectOrphanedDeltaSidecars();
 const logWriter = createConversationLogWriter({ sessionId: effectiveSessionId, dir: logWriterDir, logger });
 function buildInitMeta(id, createdAt, rolloverFrom) {
-    const cwd = executionContext?.getCwd();
+    // Persist under the session's home workspace, the same scope SessionBrowser
+    // and --resume read from. The live cwd moves into a worktree during work, so
+    // a rollover or /clear there used to hide the successor from its own scope.
+    const cwd = executionContext?.getHomeWorkspace();
     const persistedRolloverFrom = rolloverFrom ?? (resumedConversation?.id === id ? resumedConversation.rolloverFrom : undefined);
     const activeProfileId = settings.get('app.activeProfileId');
     return {
@@ -1034,6 +1128,17 @@ catch (err) {
     }
     throw err;
 }
+if (launchGoal) {
+    try {
+        logWriter.append({ type: 'goal_changed', version: 1, goal: launchGoal });
+        currentGoalState.current = launchGoal;
+    }
+    catch (error) {
+        console.error(`Unable to persist requested goal: ${error instanceof Error ? error.message : String(error)}`);
+        await logWriter.close().catch(() => undefined);
+        process.exit(1);
+    }
+}
 activeLogWriter = logWriter;
 conversationService.setLogSink((event) => logWriter.append(event));
 // Persist agent-affecting settings changes as they happen.
@@ -1042,24 +1147,76 @@ settings.onChange((key) => {
         return;
     logWriter.append({ type: 'settings_changed', key, value: settings.getDynamic(key) });
 });
-import { InputProvider } from './context/InputContext.js';
 // Do NOT wrap stdout writes with DEC Mode 2026 synchronized-output markers here.
 // Ink 7.0.1 already wraps each interactive frame in `\x1b[?2026h … \x1b[?2026l`
 // natively (node_modules/ink/build/write-synchronized.js). Re-wrapping each
 // individual write() breaks that frame-level atomicity and makes the terminal
 // paint blank/partial intermediate frames — visible flicker while streaming.
+if (!hasPositionalPrompt && (!nodeStdin.isTTY || !nodeStdout.isTTY)) {
+    console.error('term2 needs an interactive terminal; for one-shot use: term2 "<prompt>"');
+    process.exit(1);
+}
+let controlStartupNotice;
+let controlSocket;
+if (controlSocketRequested) {
+    if (controlSocketNameRejected || !controlSocketName) {
+        controlStartupNotice = `Control socket name rejected: ${controlSocketName ?? ''}`;
+    }
+    else {
+        try {
+            controlSocket = new ControlSocketServer({
+                name: controlSocketName,
+                sessionId: () => effectiveSessionId ?? conversationService.sessionId,
+            });
+            await controlSocket.listen();
+            activeControlSocketServer = controlSocket;
+            controlStartupNotice = `Control socket on: ${controlSocket.name} (pid ${process.pid})`;
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            controlStartupNotice = `Control socket off: ${reason}`;
+            if (controlSocket)
+                await controlSocket.close().catch(() => undefined);
+            controlSocket = undefined;
+        }
+    }
+}
+const [{ default: React }, { render }, { default: App }, { InputProvider }, { getInkRenderOptions }] = await Promise.all([
+    import('react'),
+    import('ink'),
+    import('./app.js'),
+    import('./context/InputContext.js'),
+    import('./utils/ink-render-options.js'),
+]);
 const { waitUntilExit } = render((React.createElement(InputProvider, null,
-    React.createElement(App, { conversationService: conversationService, settingsService: settings, historyService: history, loggingService: logger, skillsService: skillsService, sshInfo: sshInfo, sshService: sshService, usageAccumulator: sessionUsageAccumulator, subagentUsageAccumulator: subagentUsageAccumulator, costAccumulator: sessionCostAccumulator, onPrintUsage: printUsage, onExitUsage: printUsageOnce, sessionId: effectiveSessionId, initialMessages: initialMessages, restoredStaticMessageIds: restoredStaticMessageIds, logWriter: logWriter, onRotateWriter: (newId, createdAt, rolloverFrom) => {
-            logWriter.append({ type: 'session_cleared' });
-            logWriter.rotate(newId, buildInitMeta(newId, createdAt ?? new Date().toISOString(), rolloverFrom));
+    React.createElement(App, { conversationService: conversationService, controlSocket: controlSocket, controlStartupNotice: controlStartupNotice, controlSessionMetadata: () => ({
+            workspaceRoot: executionContext?.getHomeWorkspace() ?? null,
+            version: String(cli.pkg.version ?? ''),
+            createdAt: effectiveCreatedAt,
+            logPath: path.join(logWriterDir, `${effectiveSessionId ?? conversationService.sessionId}.jsonl`),
+        }), settingsService: settings, historyService: history, loggingService: logger, skillsService: skillsService, sshInfo: sshInfo, sshService: sshService, usageAccumulator: sessionUsageAccumulator, subagentUsageAccumulator: subagentUsageAccumulator, costAccumulator: sessionCostAccumulator, onPrintUsage: printUsage, onExitUsage: printUsageOnce, sessionId: effectiveSessionId, initialMessages: initialMessages, initialGoal: launchGoal ?? resumedConversation?.goal, appendGoal: (goal) => {
+            logWriter.append({ type: 'goal_changed', version: 1, goal });
+            currentGoalState.current = goal;
+        }, onGoalRestore: (goal) => {
+            currentGoalState.current = goal;
+        }, restoredStaticMessageIds: restoredStaticMessageIds, logWriter: logWriter, onRotateWriter: (newId, createdAt, rolloverFrom, rolloverGoal) => {
+            rotateSessionLog(logWriter, newId, buildInitMeta(newId, createdAt ?? new Date().toISOString(), rolloverFrom), rolloverGoal);
+            if (rolloverFrom && rolloverGoal) {
+                currentGoalState.current = rolloverGoal;
+            }
             effectiveHasConversationContent = false;
         }, generateId: generateId, onSessionIdChange: (newId, createdAt) => {
             effectiveSessionId = newId;
             effectiveCreatedAt = createdAt;
+            controlSocket?.refreshAdvertisement();
         }, onHasConversationContent: (hasContent) => {
             effectiveHasConversationContent = hasContent;
         }, terminalTitleBase: terminalTitleBase, mcpManager: mcpManager, mcpOAuthStore: mcpOAuthStore, mcpConfigController: mcpConfigController, mcpStartupNotices: mcpStartupNotices, mcpUserConfigPath: mcpConfig.userConfigPath }))), getInkRenderOptions());
 await waitUntilExit();
+if (controlSocket) {
+    await controlSocket.close();
+    activeControlSocketServer = null;
+}
 if (conversationService.hookEvents) {
     await hookService.emit(conversationService.hookEvents.create('session.end', {
         reason: 'normal',
@@ -1072,10 +1229,6 @@ await sessionBrowser.close();
 activeSessionBrowser = null;
 await logWriter.close();
 activeLogWriter = null;
-const resumeCmd = getResumeCommand(effectiveSessionId, sshFlag, sshInfo?.remoteDir, cli.flags.sshPort);
 printUsageOnce();
-if (effectiveHasConversationContent) {
-    console.log(`\nTo resume this conversation: ${resumeCmd}`);
-}
 process.exit(0);
 //# sourceMappingURL=cli.js.map