t3code-cli 0.8.0 → 0.9.1

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(

package/src/cli/thread.ts

@@ -1,10 +1,13 @@
 import { Command } from "effect/unstable/cli";
 
+import { approveThreadCommand } from "./threads/approve.ts";
 import { archiveThreadCommand } from "./threads/archive.ts";
 import { callbackThreadCommand } from "./threads/callback.ts";
 import { listThreadsCommand } from "./threads/list.ts";
 import { getThreadMessagesCommand } from "./threads/messages.ts";
+import { respondThreadCommand } from "./threads/respond.ts";
 import { sendThreadCommand } from "./threads/send.ts";
+import { showThreadCommand } from "./threads/show.ts";
 import { startThreadCommand } from "./threads/start.ts";
 import { waitForThreadCommand } from "./threads/wait.ts";
 
@@ -15,6 +18,9 @@ export function createThreadCommand() {
       listThreadsCommand,
       startThreadCommand,
       sendThreadCommand,
+      showThreadCommand,
+      approveThreadCommand,
+      respondThreadCommand,
       archiveThreadCommand,
       getThreadMessagesCommand,
       waitForThreadCommand,

package/src/cli/threads/approve.ts

@@ -0,0 +1,61 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingRequestError, MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+const approvalDecisionFlag = Flag.choice("decision", ["accept", "decline", "cancel"] as const).pipe(
+  Flag.withDescription("Approval decision"),
+);
+
+const requestFlag = Flag.string("request").pipe(
+  Flag.withDescription("Pending approval request id"),
+  Flag.optional,
+);
+
+export const approveThreadCommand = Command.make(
+  "approve",
+  {
+    thread: threadFlag,
+    request: requestFlag,
+    decision: approvalDecisionFlag,
+    format: formatFlag,
+  },
+  ({ thread, request, decision, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const requestId = Option.getOrUndefined(request);
+      if (requestId === undefined || requestId.length === 0) {
+        return yield* Effect.fail(
+          new MissingRequestError({ message: "request id is required: pass --request" }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* application.approveThread({ threadId, requestId, decision });
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(result);
+      }
+      return yield* output.printInfo(
+        `approval submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+      );
+    }),
+).pipe(Command.withDescription("respond to a pending approval request"));

package/src/cli/threads/archive.ts

@@ -1,9 +1,9 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
-import { Command } from "effect/unstable/cli";
+import { Command, Flag } from "effect/unstable/cli";
 
 import { formatFlag, threadFlag } from "../flags.ts";
-import { MissingThreadError } from "../error.ts";
+import { MissingThreadError, SelfArchiveError } from "../error.ts";
 import { resolveThreadId } from "../../scope/index.ts";
 import { T3Application } from "../../application/service.ts";
 import { Environment } from "../../environment/service.ts";
@@ -14,9 +14,10 @@ export const archiveThreadCommand = Command.make(
   "archive",
   {
     thread: threadFlag,
+    force: Flag.boolean("force").pipe(Flag.withAlias("f")),
     format: formatFlag,
   },
-  ({ thread, format }) =>
+  ({ thread, force, format }) =>
     Effect.gen(function* () {
       const application = yield* T3Application;
       const environment = yield* Environment;
@@ -32,6 +33,20 @@ export const archiveThreadCommand = Command.make(
           }),
         );
       }
+      const envThreadId = environment.env.T3CODE_THREAD_ID;
+      if (
+        envThreadId !== undefined &&
+        envThreadId.length > 0 &&
+        threadId === envThreadId &&
+        !force
+      ) {
+        return yield* Effect.fail(
+          new SelfArchiveError({
+            threadId,
+            message: `cannot archive thread ${threadId}: matches T3CODE_THREAD_ID (are you trying to archive yourself?). Use --force to override.`,
+          }),
+        );
+      }
       const resolvedFormat = resolveOutputFormat(format, environment, "json");
       const dispatch = yield* application.archiveThread(threadId);
       if (resolvedFormat === "json") {

package/src/cli/threads/callback.ts

@@ -67,8 +67,7 @@ export const callbackThreadCommand = Command.make(
         });
 
         const handle = yield* spawner.spawn(proc);
-        const reref = yield* handle.unref;
-        yield* reref.pipe(Effect.ignore);
+        yield* handle.unref.pipe(Effect.ignore);
 
         yield* output.printInfo(
           `background callback scheduled: ${fromThreadId} -> ${targetThreadId} (pid: ${handle.pid})`,

package/src/cli/threads/respond.ts

@@ -0,0 +1,70 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingRequestError, MissingThreadError } from "../error.ts";
+import { readJsonAnswers } from "../message-input.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { T3Input } from "../input/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+const requestFlag = Flag.string("request").pipe(
+  Flag.withDescription("Pending user-input request id"),
+  Flag.optional,
+);
+
+export const respondThreadCommand = Command.make(
+  "respond",
+  {
+    thread: threadFlag,
+    request: requestFlag,
+    answers: Flag.string("answers").pipe(Flag.optional),
+    stdin: Flag.boolean("stdin"),
+    format: formatFlag,
+  },
+  ({ thread, request, answers, stdin, format }) =>
+    Effect.gen(function* () {
+      const inputService = yield* T3Input;
+      const parsedAnswers = yield* readJsonAnswers({
+        answers: Option.getOrUndefined(answers),
+        fromStdin: stdin,
+        readStdin: inputService.readStdin,
+      });
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const requestId = Option.getOrUndefined(request);
+      if (requestId === undefined || requestId.length === 0) {
+        return yield* Effect.fail(
+          new MissingRequestError({ message: "request id is required: pass --request" }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const result = yield* application.respondToThread({
+        threadId,
+        requestId,
+        answers: parsedAnswers,
+      });
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(result);
+      }
+      return yield* output.printInfo(
+        `user input submitted: ${result.requestId}\nsequence: ${result.dispatch.sequence}`,
+      );
+    }),
+).pipe(Command.withDescription("respond to a pending user-input request"));

package/src/cli/threads/show.ts

@@ -0,0 +1,43 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Command } from "effect/unstable/cli";
+
+import { formatFlag, threadFlag } from "../flags.ts";
+import { MissingThreadError } from "../error.ts";
+import { resolveThreadId } from "../../scope/index.ts";
+import { formatThreadShowHuman, formatThreadShowJson } from "../thread-format.ts";
+import { T3Application } from "../../application/service.ts";
+import { Environment } from "../../environment/service.ts";
+import { resolveOutputFormat } from "../output-format.ts";
+import { T3Output } from "../output/service.ts";
+
+export const showThreadCommand = Command.make(
+  "show",
+  {
+    thread: threadFlag,
+    format: formatFlag,
+  },
+  ({ thread, format }) =>
+    Effect.gen(function* () {
+      const application = yield* T3Application;
+      const environment = yield* Environment;
+      const output = yield* T3Output;
+      const threadId = resolveThreadId({
+        value: Option.getOrUndefined(thread),
+        env: environment.env,
+      });
+      if (threadId === undefined) {
+        return yield* Effect.fail(
+          new MissingThreadError({
+            message: "thread id is required: pass --thread or set T3CODE_THREAD_ID",
+          }),
+        );
+      }
+      const resolvedFormat = resolveOutputFormat(format, environment, "json");
+      const detail = yield* application.showThread(threadId);
+      if (resolvedFormat === "json") {
+        return yield* output.printJson(formatThreadShowJson(detail));
+      }
+      return yield* output.writeStdout(formatThreadShowHuman(detail));
+    }),
+).pipe(Command.withDescription("show thread status and pending requests"));

package/src/domain/thread-activities.test.ts

@@ -0,0 +1,321 @@
+import "vite-plus/test/config";
+
+import { EventId, TurnId, type OrchestrationThreadActivity } from "#t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+
+import { derivePendingApprovals, derivePendingUserInputs } from "./thread-activities.ts";
+
+let nextActivityId = 0;
+
+function makeActivity(overrides: {
+  id?: string;
+  createdAt?: string;
+  kind?: string;
+  summary?: string;
+  tone?: OrchestrationThreadActivity["tone"];
+  payload?: Record<string, unknown>;
+  turnId?: string;
+  sequence?: number;
+}): OrchestrationThreadActivity {
+  const payload = overrides.payload ?? {};
+  return {
+    id: EventId.make(overrides.id ?? `activity-${nextActivityId++}`),
+    createdAt: overrides.createdAt ?? "2026-02-23T00:00:00.000Z",
+    kind: overrides.kind ?? "tool.started",
+    summary: overrides.summary ?? "Tool call",
+    tone: overrides.tone ?? "tool",
+    payload,
+    turnId: overrides.turnId !== undefined ? TurnId.make(overrides.turnId) : null,
+    ...(overrides.sequence !== undefined ? { sequence: overrides.sequence } : {}),
+  };
+}
+
+describe("derivePendingApprovals", () => {
+  it("tracks open approvals and removes resolved ones", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-1",
+          requestKind: "command",
+          detail: "bun run lint",
+        },
+      }),
+      makeActivity({
+        id: "approval-close",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "approval.resolved",
+        summary: "Approval resolved",
+        tone: "info",
+        payload: { requestId: "req-2" },
+      }),
+      makeActivity({
+        id: "approval-closed-request",
+        createdAt: "2026-02-23T00:00:01.500Z",
+        kind: "approval.requested",
+        summary: "File-change approval requested",
+        tone: "approval",
+        payload: { requestId: "req-2", requestKind: "file-change" },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([
+      {
+        requestId: "req-1",
+        requestKind: "command",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        detail: "bun run lint",
+      },
+    ]);
+  });
+
+  it("maps canonical requestType payloads into pending approvals", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open-request-type",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-request-type",
+          requestType: "command_execution_approval",
+          detail: "pwd",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([
+      {
+        requestId: "req-request-type",
+        requestKind: "command",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        detail: "pwd",
+      },
+    ]);
+  });
+
+  it("clears stale pending approvals when provider reports unknown pending request", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open-stale",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-stale-1",
+          requestKind: "command",
+        },
+      }),
+      makeActivity({
+        id: "approval-failed-stale",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "provider.approval.respond.failed",
+        summary: "Provider approval response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-stale-1",
+          detail: "Unknown pending permission request: req-stale-1",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([]);
+  });
+
+  it("clears stale pending approvals when request and stale failure share createdAt", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "z-approval-open-same-ts",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-same-ts-1",
+          requestKind: "command",
+        },
+      }),
+      makeActivity({
+        id: "a-approval-failed-same-ts",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "provider.approval.respond.failed",
+        summary: "Provider approval response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-same-ts-1",
+          detail: "Unknown pending permission request: req-same-ts-1",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([]);
+  });
+
+  it("clears stale pending approvals when the backend marks them stale after restart", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "approval-open-stale-restart",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "approval.requested",
+        summary: "Command approval requested",
+        tone: "approval",
+        payload: {
+          requestId: "req-stale-restart-1",
+          requestKind: "command",
+        },
+      }),
+      makeActivity({
+        id: "approval-failed-stale-restart",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "provider.approval.respond.failed",
+        summary: "Provider approval response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-stale-restart-1",
+          detail:
+            "Stale pending approval request: req-stale-restart-1. Provider callback state does not survive app restarts or recovered sessions. Restart the turn to continue.",
+        },
+      }),
+    ];
+
+    expect(derivePendingApprovals(activities)).toEqual([]);
+  });
+});
+
+describe("derivePendingUserInputs", () => {
+  it("tracks open structured prompts and removes resolved ones", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "user-input-open",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "user-input.requested",
+        summary: "User input requested",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-1",
+          questions: [
+            {
+              id: "sandbox_mode",
+              header: "Sandbox",
+              question: "Which mode should be used?",
+              options: [
+                {
+                  label: "workspace-write",
+                  description: "Allow workspace writes only",
+                },
+              ],
+              multiSelect: true,
+            },
+          ],
+        },
+      }),
+      makeActivity({
+        id: "user-input-resolved",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "user-input.resolved",
+        summary: "User input submitted",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-2",
+          answers: {
+            sandbox_mode: "workspace-write",
+          },
+        },
+      }),
+      makeActivity({
+        id: "user-input-open-2",
+        createdAt: "2026-02-23T00:00:01.500Z",
+        kind: "user-input.requested",
+        summary: "User input requested",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-2",
+          questions: [
+            {
+              id: "approval",
+              header: "Approval",
+              question: "Continue?",
+              options: [
+                {
+                  label: "yes",
+                  description: "Continue execution",
+                },
+              ],
+              multiSelect: false,
+            },
+          ],
+        },
+      }),
+    ];
+
+    expect(derivePendingUserInputs(activities)).toEqual([
+      {
+        requestId: "req-user-input-1",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        questions: [
+          {
+            id: "sandbox_mode",
+            header: "Sandbox",
+            question: "Which mode should be used?",
+            options: [
+              {
+                label: "workspace-write",
+                description: "Allow workspace writes only",
+              },
+            ],
+            multiSelect: true,
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("clears stale pending user-input prompts when the provider reports an orphaned request", () => {
+    const activities: OrchestrationThreadActivity[] = [
+      makeActivity({
+        id: "user-input-open-stale",
+        createdAt: "2026-02-23T00:00:01.000Z",
+        kind: "user-input.requested",
+        summary: "User input requested",
+        tone: "info",
+        payload: {
+          requestId: "req-user-input-stale-1",
+          questions: [
+            {
+              id: "sandbox_mode",
+              header: "Sandbox",
+              question: "Which mode should be used?",
+              options: [
+                {
+                  label: "workspace-write",
+                  description: "Allow workspace writes only",
+                },
+              ],
+              multiSelect: false,
+            },
+          ],
+        },
+      }),
+      makeActivity({
+        id: "user-input-failed-stale",
+        createdAt: "2026-02-23T00:00:02.000Z",
+        kind: "provider.user-input.respond.failed",
+        summary: "Provider user input response failed",
+        tone: "error",
+        payload: {
+          requestId: "req-user-input-stale-1",
+          detail:
+            "Stale pending user-input request: req-user-input-stale-1. Provider callback state does not survive app restarts or recovered sessions. Restart the turn to continue.",
+        },
+      }),
+    ];
+
+    expect(derivePendingUserInputs(activities)).toEqual([]);
+  });
+});