t3code-cli 0.7.0 → 0.9.0

package/dist/upstream-t3code/packages/contracts/src/server.d.ts

@@ -126,6 +126,7 @@ export declare const ServerProvider: Schema.Struct<{
         readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     }>>;
     readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+    readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
     readonly enabled: Schema.Boolean;
     readonly installed: Schema.Boolean;
     readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -213,6 +214,7 @@ export declare const ServerProviders: Schema.$Array<Schema.Struct<{
         readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     }>>;
     readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+    readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
     readonly enabled: Schema.Boolean;
     readonly installed: Schema.Boolean;
     readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -595,6 +597,7 @@ export declare const ServerConfig: Schema.Struct<{
             readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
         }>>;
         readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+        readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
         readonly enabled: Schema.Boolean;
         readonly installed: Schema.Boolean;
         readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -722,6 +725,11 @@ export declare const ServerConfig: Schema.Struct<{
                 readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
                 readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
             }>, never>;
+            readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+                readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+                readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+                readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+            }>, never>;
             readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
                 readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
                 readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -860,6 +868,7 @@ export declare const ServerConfigUpdatedPayload: Schema.Struct<{
             readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
         }>>;
         readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+        readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
         readonly enabled: Schema.Boolean;
         readonly installed: Schema.Boolean;
         readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -978,6 +987,11 @@ export declare const ServerConfigUpdatedPayload: Schema.Struct<{
                 readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
                 readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
             }>, never>;
+            readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+                readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+                readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+                readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+            }>, never>;
             readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
                 readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
                 readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -1054,6 +1068,7 @@ export declare const ServerConfigProviderStatusesPayload: Schema.Struct<{
             readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
         }>>;
         readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+        readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
         readonly enabled: Schema.Boolean;
         readonly installed: Schema.Boolean;
         readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -1175,6 +1190,11 @@ export declare const ServerConfigSettingsUpdatedPayload: Schema.Struct<{
                 readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
                 readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
             }>, never>;
+            readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+                readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+                readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+                readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+            }>, never>;
             readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
                 readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
                 readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -1271,6 +1291,7 @@ export declare const ServerConfigStreamSnapshotEvent: Schema.Struct<{
                 readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
             }>>;
             readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+            readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
             readonly enabled: Schema.Boolean;
             readonly installed: Schema.Boolean;
             readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -1398,6 +1419,11 @@ export declare const ServerConfigStreamSnapshotEvent: Schema.Struct<{
                     readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
                     readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
                 }>, never>;
+                readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+                    readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+                    readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+                    readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+                }>, never>;
                 readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
                     readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
                     readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -1482,6 +1508,7 @@ export declare const ServerConfigStreamProviderStatusesEvent: Schema.Struct<{
                 readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
             }>>;
             readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+            readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
             readonly enabled: Schema.Boolean;
             readonly installed: Schema.Boolean;
             readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -1607,6 +1634,11 @@ export declare const ServerConfigStreamSettingsUpdatedEvent: Schema.Struct<{
                     readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
                     readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
                 }>, never>;
+                readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+                    readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+                    readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+                    readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+                }>, never>;
                 readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
                     readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
                     readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -1704,6 +1736,7 @@ export declare const ServerConfigStreamEvent: Schema.Union<readonly [Schema.Stru
                 readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
             }>>;
             readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+            readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
             readonly enabled: Schema.Boolean;
             readonly installed: Schema.Boolean;
             readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -1831,6 +1864,11 @@ export declare const ServerConfigStreamEvent: Schema.Union<readonly [Schema.Stru
                     readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
                     readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
                 }>, never>;
+                readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+                    readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+                    readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+                    readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+                }>, never>;
                 readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
                     readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
                     readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -1911,6 +1949,7 @@ export declare const ServerConfigStreamEvent: Schema.Union<readonly [Schema.Stru
                 readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
             }>>;
             readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+            readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
             readonly enabled: Schema.Boolean;
             readonly installed: Schema.Boolean;
             readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -2034,6 +2073,11 @@ export declare const ServerConfigStreamEvent: Schema.Union<readonly [Schema.Stru
                     readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
                     readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
                 }>, never>;
+                readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+                    readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+                    readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+                    readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+                }>, never>;
                 readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
                     readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
                     readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -2197,6 +2241,7 @@ export declare const ServerProviderUpdatedPayload: Schema.Struct<{
             readonly groupKey: Schema.decodeTo<Schema.String, Schema.String, never, never>;
         }>>;
         readonly showInteractionModeToggle: Schema.optional<Schema.Boolean>;
+        readonly requiresNewThreadForModelChange: Schema.optional<Schema.Boolean>;
         readonly enabled: Schema.Boolean;
         readonly installed: Schema.Boolean;
         readonly version: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;

package/dist/upstream-t3code/packages/contracts/src/settings.d.ts

@@ -3,6 +3,9 @@ import * as Schema from "effect/Schema";
 export declare const TimestampFormat: Schema.Literals<readonly ["locale", "12-hour", "24-hour"]>;
 export type TimestampFormat = typeof TimestampFormat.Type;
 export declare const DEFAULT_TIMESTAMP_FORMAT: TimestampFormat;
+export declare const ContextMenuStyle: Schema.Literals<readonly ["default", "native", "custom"]>;
+export type ContextMenuStyle = typeof ContextMenuStyle.Type;
+export declare const DEFAULT_CONTEXT_MENU_STYLE: ContextMenuStyle;
 export declare const SidebarProjectSortOrder: Schema.Literals<readonly ["updated_at", "created_at", "manual"]>;
 export type SidebarProjectSortOrder = typeof SidebarProjectSortOrder.Type;
 export declare const DEFAULT_SIDEBAR_PROJECT_SORT_ORDER: SidebarProjectSortOrder;
@@ -21,6 +24,7 @@ export declare const ClientSettingsSchema: Schema.Struct<{
     readonly autoOpenPlanSidebar: Schema.withDecodingDefault<Schema.Boolean, never>;
     readonly confirmThreadArchive: Schema.withDecodingDefault<Schema.Boolean, never>;
     readonly confirmThreadDelete: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly contextMenuStyle: Schema.withDecodingDefault<Schema.Literals<readonly ["default", "native", "custom"]>, never>;
     readonly dismissedProviderUpdateNotificationKeys: Schema.withDecodingDefault<Schema.$Array<Schema.decodeTo<Schema.String, Schema.String, never, never>>, never>;
     readonly diffIgnoreWhitespace: Schema.withDecodingDefault<Schema.Boolean, never>;
     readonly diffWordWrap: Schema.withDecodingDefault<Schema.Boolean, never>;
@@ -88,6 +92,12 @@ export declare const CursorSettings: Schema.Struct<{
     readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
 }>;
 export type CursorSettings = typeof CursorSettings.Type;
+export declare const GrokSettings: Schema.Struct<{
+    readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+    readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+    readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+}>;
+export type GrokSettings = typeof GrokSettings.Type;
 export declare const OpenCodeSettings: Schema.Struct<{
     readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
     readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -144,6 +154,11 @@ export declare const ServerSettings: Schema.Struct<{
             readonly apiEndpoint: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.String, never, never>, never>;
             readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
         }>, never>;
+        readonly grok: Schema.withDecodingDefault<Schema.Struct<{
+            readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
+            readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
+            readonly customModels: Schema.withDecodingDefault<Schema.$Array<Schema.String>, never>;
+        }>, never>;
         readonly opencode: Schema.withDecodingDefault<Schema.Struct<{
             readonly enabled: Schema.withDecodingDefault<Schema.Boolean, never>;
             readonly binaryPath: Schema.withDecodingDefault<Schema.decodeTo<Schema.String, Schema.decodeTo<Schema.String, Schema.String, never, never>, never, never>, never>;
@@ -223,6 +238,11 @@ export declare const ServerSettingsPatch: Schema.Struct<{
             readonly apiEndpoint: Schema.optionalKey<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
             readonly customModels: Schema.optionalKey<Schema.$Array<Schema.String>>;
         }>>;
+        readonly grok: Schema.optionalKey<Schema.Struct<{
+            readonly enabled: Schema.optionalKey<Schema.Boolean>;
+            readonly binaryPath: Schema.optionalKey<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+            readonly customModels: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>>;
         readonly opencode: Schema.optionalKey<Schema.Struct<{
             readonly enabled: Schema.optionalKey<Schema.Boolean>;
             readonly binaryPath: Schema.optionalKey<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
@@ -250,6 +270,7 @@ export declare const ClientSettingsPatch: Schema.Struct<{
     readonly autoOpenPlanSidebar: Schema.optionalKey<Schema.Boolean>;
     readonly confirmThreadArchive: Schema.optionalKey<Schema.Boolean>;
     readonly confirmThreadDelete: Schema.optionalKey<Schema.Boolean>;
+    readonly contextMenuStyle: Schema.optionalKey<Schema.Literals<readonly ["default", "native", "custom"]>>;
     readonly diffIgnoreWhitespace: Schema.optionalKey<Schema.Boolean>;
     readonly diffWordWrap: Schema.optionalKey<Schema.Boolean>;
     readonly favorites: Schema.optionalKey<Schema.$Array<Schema.Struct<{

package/dist/upstream-t3code/packages/contracts/src/terminal.d.ts

@@ -21,10 +21,11 @@ export declare const TerminalOpenInput: Schema.Struct<{
     readonly cols: Schema.optional<Schema.Int>;
     readonly rows: Schema.optional<Schema.Int>;
     readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly projectId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProjectId">>;
     readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
 }>;
-export type TerminalOpenInput = Schema.Codec.Encoded<typeof TerminalOpenInput>;
+export type TerminalOpenInput = typeof TerminalOpenInput.Type;
 export declare const TerminalAttachInput: Schema.Struct<{
     readonly cwd: Schema.optional<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
     readonly worktreePath: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>>;
@@ -32,10 +33,11 @@ export declare const TerminalAttachInput: Schema.Struct<{
     readonly rows: Schema.optional<Schema.Int>;
     readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     readonly restartIfNotRunning: Schema.optional<Schema.Boolean>;
+    readonly projectId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProjectId">>;
     readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
 }>;
-export type TerminalAttachInput = Schema.Codec.Encoded<typeof TerminalAttachInput>;
+export type TerminalAttachInput = typeof TerminalAttachInput.Type;
 export declare const TerminalWriteInput: Schema.Struct<{
     readonly data: Schema.String;
     readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
@@ -60,10 +62,11 @@ export declare const TerminalRestartInput: Schema.Struct<{
     readonly cols: Schema.Int;
     readonly rows: Schema.Int;
     readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly projectId: Schema.optional<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ProjectId">>;
     readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
     readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
 }>;
-export type TerminalRestartInput = Schema.Codec.Encoded<typeof TerminalRestartInput>;
+export type TerminalRestartInput = typeof TerminalRestartInput.Type;
 export declare const TerminalCloseInput: Schema.Struct<{
     readonly terminalId: Schema.optional<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
     readonly deleteHistory: Schema.optional<Schema.Boolean>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",
@@ -98,7 +98,7 @@
     "@types/node": "^25.9.1",
     "typescript": "^6.0.3",
     "vite-plus": "^0.1.24",
-    "@t3tools/contracts": "0.0.24"
+    "@t3tools/contracts": "0.0.27"
   },
   "engines": {
     "node": ">=24.0.0"

package/src/application/service.ts

@@ -9,10 +9,12 @@ import type {
   OrchestrationShellSnapshot,
   OrchestrationThread,
   OrchestrationThreadShell,
+  ProviderUserInputAnswers,
   ServerProvider,
 } from "#t3tools/contracts";
 
 import type { ApplicationError } from "./error.ts";
+import type { ThreadShow } from "./threads.ts";
 
 export type StartThreadInput = {
   readonly projectRef?: string;
@@ -30,6 +32,12 @@ export type SendThreadInput = {
   readonly options?: NonNullable<ModelSelection["options"]>;
 };
 
+export type CallbackThreadInput = {
+  readonly fromThreadId: string;
+  readonly targetThreadId: string;
+  readonly prompt: string;
+};
+
 export type StartThreadPolicy = {
   readonly until: "dispatch" | "visible" | "complete";
 };
@@ -65,6 +73,23 @@ export class T3Application extends Context.Service<
     readonly getThreadMessages: (
       threadId: string,
     ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly showThread: (threadId: string) => Effect.Effect<ThreadShow, ApplicationError>;
+    readonly approveThread: (input: {
+      readonly threadId: string;
+      readonly requestId: string;
+      readonly decision: "accept" | "decline" | "cancel";
+    }) => Effect.Effect<
+      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+      ApplicationError
+    >;
+    readonly respondToThread: (input: {
+      readonly threadId: string;
+      readonly requestId: string;
+      readonly answers: ProviderUserInputAnswers;
+    }) => Effect.Effect<
+      { readonly threadId: string; readonly requestId: string; readonly dispatch: DispatchResult },
+      ApplicationError
+    >;
     readonly archiveThread: (threadId: string) => Effect.Effect<DispatchResult, ApplicationError>;
     readonly startThread: (
       input: StartThreadInput,
@@ -93,5 +118,12 @@ export class T3Application extends Context.Service<
     readonly waitForThread: (
       threadId: string,
     ) => Effect.Effect<OrchestrationThread, ApplicationError>;
+    readonly callbackThread: (input: CallbackThreadInput) => Effect.Effect<
+      {
+        readonly dispatch: DispatchResult;
+        readonly targetThreadId: string;
+      },
+      ApplicationError
+    >;
   }
 >()("t3cli/T3Application") {}

package/src/application/thread-commands.ts

@@ -2,12 +2,15 @@ import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import {
+  ApprovalRequestId,
   CommandId,
   MessageId,
   ThreadId,
   type ClientOrchestrationCommand,
   type ModelSelection,
   type OrchestrationProjectShell,
+  type ProviderApprovalDecision,
+  type ProviderUserInputAnswers,
 } from "#t3tools/contracts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import { resolveModelSelection } from "./model-selection.ts";
@@ -97,3 +100,45 @@ export const makeThreadArchiveCommand = Effect.fn("makeThreadArchiveCommand")(fu
     threadId: ThreadId.make(threadId),
   } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.archive" }>;
 });
+
+export const makeThreadApprovalRespondCommand = Effect.fn("makeThreadApprovalRespondCommand")(
+  function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: ProviderApprovalDecision;
+  }) {
+    const crypto = yield* Crypto.Crypto;
+    const createdAt = DateTime.formatIso(yield* DateTime.now);
+    return {
+      type: "thread.approval.respond",
+      commandId: CommandId.make(
+        `t3cli:thread-approve:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      threadId: ThreadId.make(input.threadId),
+      requestId: ApprovalRequestId.make(input.requestId),
+      decision: input.decision,
+      createdAt,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.approval.respond" }>;
+  },
+);
+
+export const makeThreadUserInputRespondCommand = Effect.fn("makeThreadUserInputRespondCommand")(
+  function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+  }) {
+    const crypto = yield* Crypto.Crypto;
+    const createdAt = DateTime.formatIso(yield* DateTime.now);
+    return {
+      type: "thread.user-input.respond",
+      commandId: CommandId.make(
+        `t3cli:thread-respond:${yield* crypto.randomUUIDv4.pipe(Effect.orDie)}`,
+      ),
+      threadId: ThreadId.make(input.threadId),
+      requestId: ApprovalRequestId.make(input.requestId),
+      answers: input.answers,
+      createdAt,
+    } satisfies Extract<ClientOrchestrationCommand, { readonly type: "thread.user-input.respond" }>;
+  },
+);

package/src/application/threads.ts

@@ -7,12 +7,18 @@ import { T3Orchestration } from "../orchestration/service.ts";
 import { ProjectLookupError, ThreadSessionError } from "../domain/error.ts";
 import { resolveProjectScope } from "../domain/helpers.ts";
 import { type StartThreadInput } from "./service.ts";
-import type { SendThreadInput } from "./service.ts";
+import type { SendThreadInput, CallbackThreadInput } from "./service.ts";
 import { mergeModelOptions } from "./model-selection.ts";
+import { derivePendingApprovals, derivePendingUserInputs } from "../domain/thread-activities.ts";
+import { threadStatus, type ThreadLifecycleStatus } from "../domain/thread-lifecycle.ts";
+import type { OrchestrationThread } from "#t3tools/contracts";
+import type { ProviderApprovalDecision, ProviderUserInputAnswers } from "#t3tools/contracts";
 import {
+  makeThreadApprovalRespondCommand,
   makeThreadArchiveCommand,
   makeThreadStartCommands,
   makeThreadTurnContinueCommand,
+  makeThreadUserInputRespondCommand,
 } from "./thread-commands.ts";
 import {
   waitForThread as waitForThreadUntilComplete,
@@ -45,6 +51,10 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
   ) {
     return yield* orchestration.getThreadSnapshot(threadId);
   });
+  const showThread = Effect.fn("T3ApplicationLive.showThread")(function* (threadId: string) {
+    const thread = yield* orchestration.getThreadSnapshot(threadId);
+    return projectThreadShow(thread);
+  });
   const archiveThread = Effect.fn("T3ApplicationLive.archiveThread")(function* (threadId: string) {
     const command = yield* makeThreadArchiveCommand(threadId).pipe(
       Effect.provideService(Crypto.Crypto, crypto),
@@ -171,18 +181,107 @@ export const makeThreadApplication = Effect.fn("makeThreadApplication")(function
     yield* failIfThreadError(thread);
     return thread;
   });
+  const callbackThread = Effect.fn("T3ApplicationLive.callbackThread")(function* (
+    input: CallbackThreadInput,
+  ) {
+    yield* waitForThreadUntilComplete({
+      orchestration,
+      threadId: input.fromThreadId,
+    });
+    const result = yield* sendThread(
+      { threadId: input.targetThreadId, message: input.prompt },
+      { until: "dispatch" },
+    );
+    return { dispatch: result.dispatch, targetThreadId: input.targetThreadId };
+  });
+  const approveThread = Effect.fn("T3ApplicationLive.approveThread")(function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly decision: ProviderApprovalDecision;
+  }) {
+    const command = yield* makeThreadApprovalRespondCommand(input).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    const dispatch = yield* orchestration.dispatch(command);
+    return { threadId: input.threadId, requestId: input.requestId, dispatch };
+  });
+  const respondToThread = Effect.fn("T3ApplicationLive.respondToThread")(function* (input: {
+    readonly threadId: string;
+    readonly requestId: string;
+    readonly answers: ProviderUserInputAnswers;
+  }) {
+    const command = yield* makeThreadUserInputRespondCommand(input).pipe(
+      Effect.provideService(Crypto.Crypto, crypto),
+    );
+    const dispatch = yield* orchestration.dispatch(command);
+    return { threadId: input.threadId, requestId: input.requestId, dispatch };
+  });
 
   return {
+    approveThread,
     archiveThread,
     listThreads,
     getThreadMessages,
+    respondToThread,
     sendThread,
+    showThread,
     startThread,
     watchThread,
     waitForThread,
+    callbackThread,
   };
 });
 
+export type ThreadShow = {
+  readonly id: string;
+  readonly projectId: string;
+  readonly title: string;
+  readonly status: ThreadLifecycleStatus;
+  readonly session: OrchestrationThread["session"];
+  readonly latestTurn: OrchestrationThread["latestTurn"];
+  readonly modelSelection: OrchestrationThread["modelSelection"];
+  readonly runtimeMode: OrchestrationThread["runtimeMode"];
+  readonly interactionMode: OrchestrationThread["interactionMode"];
+  readonly branch: OrchestrationThread["branch"];
+  readonly worktreePath: OrchestrationThread["worktreePath"];
+  readonly archivedAt: OrchestrationThread["archivedAt"];
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly messageCount: number;
+  readonly hasPendingApprovals: boolean;
+  readonly hasPendingUserInput: boolean;
+  readonly hasActionableProposedPlan: boolean;
+  readonly pendingApprovals: ReturnType<typeof derivePendingApprovals>;
+  readonly pendingUserInputs: ReturnType<typeof derivePendingUserInputs>;
+};
+
+function projectThreadShow(thread: OrchestrationThread): ThreadShow {
+  const pendingApprovals = derivePendingApprovals(thread.activities);
+  const pendingUserInputs = derivePendingUserInputs(thread.activities);
+  return {
+    id: thread.id,
+    projectId: thread.projectId,
+    title: thread.title,
+    status: threadStatus(thread),
+    session: thread.session,
+    latestTurn: thread.latestTurn,
+    modelSelection: thread.modelSelection,
+    runtimeMode: thread.runtimeMode,
+    interactionMode: thread.interactionMode,
+    branch: thread.branch,
+    worktreePath: thread.worktreePath,
+    archivedAt: thread.archivedAt,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    messageCount: thread.messages.length,
+    hasPendingApprovals: pendingApprovals.length > 0,
+    hasPendingUserInput: pendingUserInputs.length > 0,
+    hasActionableProposedPlan: thread.proposedPlans.some((plan) => plan.implementedAt === null),
+    pendingApprovals,
+    pendingUserInputs,
+  };
+}
+
 function failIfThreadError(thread: {
   readonly id: string;
   readonly session: { readonly status: string; readonly lastError: string | null } | null;

package/src/cli/error.ts

@@ -21,3 +21,18 @@ export class MissingThreadError extends Schema.TaggedErrorClass<MissingThreadErr
     message: Schema.String,
   },
 ) {}
+
+export class SelfArchiveError extends Schema.TaggedErrorClass<SelfArchiveError>()(
+  "SelfArchiveError",
+  {
+    message: Schema.String,
+    threadId: Schema.String,
+  },
+) {}
+
+export class MissingRequestError extends Schema.TaggedErrorClass<MissingRequestError>()(
+  "MissingRequestError",
+  {
+    message: Schema.String,
+  },
+) {}

package/src/cli/message-input.ts

@@ -1,4 +1,6 @@
 import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { ProviderUserInputAnswers } from "#t3tools/contracts";
 
 import { MessageInputError } from "./error.ts";
 import type { InputError } from "./input/error.ts";
@@ -23,3 +25,31 @@ export function readInitialMessage(input: {
   }
   return Effect.succeed(input.message);
 }
+
+export function readJsonAnswers(input: {
+  readonly answers: string | undefined;
+  readonly fromStdin: boolean;
+  readonly readStdin: () => Effect.Effect<string, InputError>;
+}) {
+  if (input.answers !== undefined && input.answers.length > 0 && input.fromStdin) {
+    return Effect.fail(new MessageInputError({ message: "pass --answers or --stdin, not both" }));
+  }
+  if (input.fromStdin) {
+    return input.readStdin().pipe(Effect.flatMap(parseJsonAnswers));
+  }
+  if (input.answers === undefined || input.answers.length === 0) {
+    return Effect.fail(
+      new MessageInputError({ message: "answers required unless --stdin is used" }),
+    );
+  }
+  return parseJsonAnswers(input.answers);
+}
+
+function parseJsonAnswers(text: string) {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return Effect.succeed(Schema.decodeUnknownSync(ProviderUserInputAnswers)(parsed));
+  } catch {
+    return Effect.fail(new MessageInputError({ message: "invalid JSON in answers" }));
+  }
+}

package/src/cli/thread-format.ts

@@ -1,7 +1,54 @@
+import type { ThreadShow } from "../application/threads.ts";
 import type { WaitEvent } from "../application/service.ts";
 import type { OrchestrationThread, OrchestrationThreadShell } from "#t3tools/contracts";
 import { latestAssistantMessage, threadStatus } from "../domain/thread-lifecycle.ts";
 
+export function formatThreadShowJson(thread: ThreadShow) {
+  return {
+    id: thread.id,
+    projectId: thread.projectId,
+    title: thread.title,
+    status: thread.status,
+    session: thread.session,
+    latestTurn: thread.latestTurn,
+    modelSelection: thread.modelSelection,
+    runtimeMode: thread.runtimeMode,
+    interactionMode: thread.interactionMode,
+    branch: thread.branch,
+    worktreePath: thread.worktreePath,
+    archivedAt: thread.archivedAt,
+    createdAt: thread.createdAt,
+    updatedAt: thread.updatedAt,
+    messageCount: thread.messageCount,
+    hasPendingApprovals: thread.hasPendingApprovals,
+    hasPendingUserInput: thread.hasPendingUserInput,
+    hasActionableProposedPlan: thread.hasActionableProposedPlan,
+    pendingApprovals: thread.pendingApprovals,
+    pendingUserInputs: thread.pendingUserInputs,
+  };
+}
+
+export function formatThreadShowHuman(thread: ThreadShow) {
+  const lines = [
+    `title: ${thread.title}`,
+    `id: ${thread.id}`,
+    `status: ${thread.status}`,
+    `model: ${thread.modelSelection.instanceId}/${thread.modelSelection.model}`,
+    ...(thread.branch !== null ? [`branch: ${thread.branch}`] : []),
+    ...(thread.worktreePath !== null ? [`worktree: ${thread.worktreePath}`] : []),
+    `messages: ${thread.messageCount}`,
+  ];
+  if (thread.pendingApprovals.length > 0) {
+    const requestIds = thread.pendingApprovals.map((approval) => approval.requestId).join(", ");
+    lines.push(`pending approvals: ${thread.pendingApprovals.length} (${requestIds})`);
+  }
+  if (thread.pendingUserInputs.length > 0) {
+    const requestIds = thread.pendingUserInputs.map((input) => input.requestId).join(", ");
+    lines.push(`pending user inputs: ${thread.pendingUserInputs.length} (${requestIds})`);
+  }
+  return `${lines.join("\n")}\n`;
+}
+
 export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShell>) {
   return threads
     .map(