fix(terminal): address PR #23794 review feedback from egdev6

- Remove duplicated -l args in pty.create() calls (Pty.create already calculates them)
- Parse NUL meta frame in createMockSocket() to extract PTY cursor correctly
- Store output and cursor in SessionState for persistence after PTY exit
- Add backward compat test: command-only params with action omitted (z.preprocess)
- Remove duplicated focus effect in terminal-panel.tsx
- Use source="agent" field for agent session detection instead of title prefix
- Add source field to Pty.Info and CreateInput schemas

Author: herjarsa

packages/app/src/context/terminal.tsx

@@ -16,6 +16,7 @@ export type LocalPTY = {
   buffer?: string
   scrollY?: number
   cursor?: number
+  source?: "user" | "agent"
 }
 
 const WORKSPACE_KEY = "__workspace__"
@@ -192,6 +193,7 @@ function createWorkspaceTerminalSession(sdk: ReturnType<typeof useSDK>, dir: str
       id: info.id,
       title: info.title,
       titleNumber: info.titleNumber ?? numberFromTitle(info.title) ?? 0,
+      source: info.source,
     }
     setStore("all", store.all.length, newTerminal)
   })

packages/app/src/pages/session/terminal-panel.tsx

@@ -73,7 +73,7 @@ export function TerminalPanel() {
         if (prevCount === undefined || count <= prevCount) return
         const all = terminal.all()
         const last = all[all.length - 1]
-        if (!last?.title.startsWith("Agent:")) return
+        if (last?.source !== "agent") return
         if (!opened()) view().terminal.open()
         terminal.open(last.id)
       },
@@ -114,17 +114,6 @@ export function TerminalPanel() {
     }
   }
 
-  createEffect(
-    on(
-      () => [opened(), terminal.active()] as const,
-      ([next, id]) => {
-        if (!next || !id) return
-        const stop = focus(id)
-        onCleanup(stop)
-      },
-    ),
-  )
-
   createEffect(() => {
     if (opened()) return
     const active = document.activeElement

packages/opencode/src/pty/index.ts

@@ -62,18 +62,20 @@ export const Info = Schema.Struct({
   cwd: Schema.String,
   status: Schema.Literals(["running", "exited"]),
   pid: Schema.Number,
+  source: Schema.optional(Schema.Literals(["user", "agent"])),
 })
   .annotate({ identifier: "Pty" })
   .pipe(withStatics((s) => ({ zod: zod(s) })))
 
-export type Info = Types.DeepMutable<Schema.Schema.Type<typeof Info>>
+export type Info = Types.DeepMutable<Schema.Schema.Type<typof Info>>
 
 export const CreateInput = Schema.Struct({
   command: Schema.optional(Schema.String),
   args: Schema.optional(Schema.Array(Schema.String)),
   cwd: Schema.optional(Schema.String),
   title: Schema.optional(Schema.String),
   env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
+  source: Schema.optional(Schema.Literals(["user", "agent"])),
 }).pipe(withStatics((s) => ({ zod: zod(s) })))
 
 export type CreateInput = Types.DeepMutable<Schema.Schema.Type<typeof CreateInput>>
@@ -215,6 +217,7 @@ export const layer = Layer.effect(
         cwd,
         status: "running",
         pid: proc.pid,
+        source: input.source ?? ("user" as const),
       } as const
       const session: Active = {
         info,

packages/opencode/src/tool/terminal.ts

@@ -33,7 +33,20 @@ type SessionState = {
   shell: string
   createdAt: number
   exitCode: number | null
-}
+  buffer: string
+}  
+
+/* ... */
+
+        sessions.set(info.id, {
+          ptyId: info.id,
+          lastCursor: 0,
+          description: desc,
+          shell,
+          createdAt: Date.now(),
+          exitCode: null,
+          buffer: "",
+        })
 
 // ---------------------------------------------------------------------------
 // Sentinel command helper (shell-aware)
@@ -54,7 +67,7 @@ export function sentinelCommand(shellName: string): string {
 // ---------------------------------------------------------------------------
 
 const RunAction = z.object({
-  action: z.literal("run").default("run"),
+  action: z.literal("run"),
   command: z.string().describe("The command to execute in a TTY-aware terminal session"),
   timeout: z.number().describe("Optional timeout in milliseconds").optional(),
   workdir: z
@@ -92,7 +105,15 @@ const CloseAction = z.object({
   sessionId: PtyID.zod.describe("ID of the terminal session to close"),
 })
 
-const Parameters = z.discriminatedUnion("action", [RunAction, CreateAction, SendAction, ReadAction, CloseAction])
+export const Parameters = z.preprocess(
+  (data: unknown) => {
+    if (typeof data === "object" && data !== null && "command" in data && !("action" in data)) {
+      return { ...data, action: "run" }
+    }
+    return data
+  },
+  z.discriminatedUnion("action", [RunAction, CreateAction, SendAction, ReadAction, CloseAction]),
+)
 
 // ---------------------------------------------------------------------------
 // Pure helpers (unit-testable)
@@ -104,7 +125,6 @@ const Parameters = z.discriminatedUnion("action", [RunAction, CreateAction, Send
  * matches the command (trimmed), we remove it.
  */
 export function filterEcho(text: string, command: string): string {
-  const lines = text.split("\n")
   if (lines.length === 0) return text
   const firstLine = lines[0].replace(/\r$/, "").trim()
   if (firstLine === command.trim()) {
@@ -151,15 +171,30 @@ type MockSocket = {
   close: (code?: number, reason?: string) => void
 }
 
-function createMockSocket(onData: (chunk: string) => void): MockSocket {
+function createMockSocket(
+  onData: (chunk: string) => void,
+  onMeta?: (cursor: number) => void,
+): MockSocket {
   return {
     readyState: 1, // OPEN
     data: {},
     send(data: string | Uint8Array | ArrayBuffer) {
       if (typeof data === "string") {
         onData(data)
       } else {
-        onData(new TextDecoder().decode(data))
+        const buf = data instanceof Uint8Array ? data : new Uint8Array(data)
+        if (buf.length > 0 && buf[0] === 0x00) {
+          // Meta frame: 0x00 + JSON
+          const json = new TextDecoder().decode(buf.slice(1))
+          try {
+            const meta = JSON.parse(json)
+            onMeta?.(meta.cursor)
+          } catch (e) {
+            // Invalid meta - ignore
+          }
+        } else {
+          onData(new TextDecoder().decode(buf))
+        }
       }
     },
     close() {
@@ -259,10 +294,10 @@ export const TerminalTool = Tool.define(
 
               const info = yield* pty.create({
                 command: Shell.preferred(),
-                args: Shell.login(Shell.preferred()) ? ["-l"] : [],
                 cwd,
                 title: `Agent: ${params.description.slice(0, 30)}`,
                 env,
+                source: "agent",
               })
 
               yield* Effect.addFinalizer(() => pty.remove(info.id).pipe(Effect.orDie))
@@ -429,10 +464,10 @@ export const TerminalTool = Tool.define(
 
             const info = yield* pty.create({
               command: Shell.preferred(),
-              args: Shell.login(Shell.preferred()) ? ["-l"] : [],
               cwd,
-              title: `Agent: ${desc.slice(0, 30)}`,
+              title: desc.slice(0, 30),
               env,
+              source: "agent",
             })
 
             sessions.set(info.id, {
@@ -554,29 +589,30 @@ export const TerminalTool = Tool.define(
 
             // Use a temporary mock socket to capture output from lastCursor
             let newOutput = ""
-            const readWs = createMockSocket((chunk) => {
-              newOutput += chunk
-            })
+            let currentCursor = session.lastCursor
 
-            const conn = yield* pty.connect(session.ptyId, readWs, session.lastCursor)
+            const readWs = createMockSocket(
+              (chunk) => {
+                newOutput += chunk
+              },
+              (cursor) => {
+                currentCursor = cursor
+              },
+            )
 
-            // Parse cursor from the meta frame (0x00-prefixed JSON at end)
-            // The PTY service sends meta with cursor at the end of replay
-            // We can read the current cursor from the session info
-            const ptyInfo = yield* pty.get(session.ptyId)
+            const conn = yield* pty.connect(session.ptyId, readWs, session.lastCursor)
 
             if (conn) {
               conn.onClose()
             }
 
-            // Strip ANSI, clean up output
             const stripped = stripAnsi(newOutput)
             const cleaned = stripped.trim()
 
-            // Update cursor — advance by output length
-            session.lastCursor += newOutput.length
+            session.lastCursor = currentCursor
+            session.buffer += newOutput
 
-            const exitCode = ptyInfo?.status === "exited" ? session.exitCode ?? 0 : null
+            const exitCode = session.exitCode !== null ? session.exitCode : null
 
             let finalOutput = cleaned
             if (!finalOutput) finalOutput = "(no new output)"

packages/opencode/test/tool/terminal.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Layer } from "effect"
-import { sentinelCommand, filterEcho, extractExit, cleanOutput, TerminalTool } from "../../src/tool/terminal"
+import { sentinelCommand, filterEcho, extractExit, cleanOutput, TerminalTool, Parameters } from "../../src/tool/terminal"
 import * as Tool from "../../src/tool/tool"
 import { Pty } from "../../src/pty"
 import { PtyID } from "../../src/pty/schema"
@@ -237,6 +237,15 @@ describe("terminal tool integration", () => {
   // process exit. In the test context (testEffect + provideTmpdirInstance), the bus event
   // doesn't propagate to the subscriber because Instance.provide creates a separate
   // async context. In production (full opencode runtime), this works correctly.
+  it("parses command-only params (backward compat: action omitted defaults to run)", () => {
+    const parsed = Parameters.parse({ command: "ls", description: "List files" })
+    expect(parsed).toEqual(expect.objectContaining({
+      action: "run",
+      command: "ls",
+      description: "List files",
+    }))
+  })
+
   // The "run" action is backward-compatible with the existing bash tool, which has
   // its own comprehensive test suite (bash.test.ts).
   it.live.skip("backward compat: explicit run action", () =>