open-claude-p 1.1.3 → 1.2.2

package/src/options/index.js

@@ -2,3 +2,4 @@
 export { OPTION_SPEC, getOption } from './spec.js';
 export { parseArgv } from './parse-argv.js';
 export { CROSS_RULES, validate } from './validate.js';
+export { forwardedRequestFields, fieldNameFor } from './forward.js';

package/src/options/parse-argv.js

@@ -26,15 +26,20 @@ import { OPTION_SPEC, getOption } from './spec.js';
  * @property {string[]} positional
  * @property {string[]} unknown      Tokens that look like flags but were not in the spec.
  * @property {string[]} errors       Human-readable error strings.
+ * @property {Set<string>} supplied  Canonical names actually present in argv.
+ *   Defaults are pre-seeded into `options`, so a value alone cannot tell
+ *   "user passed `--flag=false`" apart from "user passed nothing" — this
+ *   set is the only way to distinguish them.
  */
 
 /**
  * @param {string[]} argv
+ * @param {Record<string, string|undefined>} [env]  defaults to `process.env`
  * @returns {ParseResult}
  */
-export function parseArgv(argv) {
+export function parseArgv(argv, env = process.env) {
   /** @type {ParseResult} */
-  const out = { options: {}, positional: [], unknown: [], errors: [] };
+  const out = { options: {}, positional: [], unknown: [], errors: [], supplied: new Set() };
 
   // Pre-seed defaults so the validator sees them.
   for (const spec of OPTION_SPEC) {
@@ -43,6 +48,14 @@ export function parseArgv(argv) {
     }
   }
 
+  // Canonical names supplied on the command line. Used only by the
+  // env-var pass at the end: argv always wins over the environment, and
+  // that has to include an explicit opt-out like `--print-mode=false`,
+  // whose value is indistinguishable from the default if you compare
+  // values instead of tracking what was actually seen.
+  /** @type {Set<string>} */
+  const supplied = out.supplied;
+
   let i = 0;
   while (i < argv.length) {
     const tok = argv[i];
@@ -63,6 +76,7 @@ export function parseArgv(argv) {
         i++;
         continue;
       }
+      supplied.add(spec.name);
       i = consumeOption(spec, argv, i, inline, out);
       continue;
     }
@@ -93,11 +107,13 @@ export function parseArgv(argv) {
             );
             break;
           }
+          supplied.add(spec.name);
           i = consumeOption(spec, argv, i, undefined, out);
           consumedByValue = true;
           break;
         }
         // Boolean short: just set.
+        supplied.add(spec.name);
         out.options[spec.name] = true;
       }
       if (!consumedByValue) i++;
@@ -109,9 +125,64 @@ export function parseArgv(argv) {
     i++;
   }
 
+  applyEnvFallbacks(out, supplied, env);
+
   return out;
 }
 
+/**
+ * Fill in options that were not supplied on the command line from their
+ * declared `env:` variable.
+ *
+ * OPTION_SPEC has always documented an `env` field, but nothing read it —
+ * the two entries that used it (`--print-mode`, `--no-session-persistence`)
+ * were wired up by hand at their call sites instead, so any new entry that
+ * declared `env` silently did nothing. This makes the declaration real, and
+ * keeps the precedence the hand-rolled versions already used:
+ *
+ *   explicit argv  >  environment variable  >  spec default
+ *
+ * Booleans accept `1` / `true` / `yes` / `on` (case-insensitive); anything
+ * else, including the empty string, leaves the option at its default so
+ * `VAR=` and `VAR=0` both read as "off". Value-taking options are coerced
+ * through the same `coerce()` path as argv, and a malformed value produces
+ * the same style of error rather than being silently ignored.
+ *
+ * @param {ParseResult} out
+ * @param {Set<string>} supplied  canonical names seen on the command line
+ * @param {Record<string, string|undefined>} env
+ */
+function applyEnvFallbacks(out, supplied, env) {
+  for (const spec of OPTION_SPEC) {
+    if (!spec.env) continue;
+    const raw = Object.prototype.hasOwnProperty.call(env ?? {}, spec.env)
+      ? env[spec.env]
+      : undefined;
+    // Library callers can pass any object as `env`; only honour real
+    // string values so a stray number/object cannot throw in `.trim()`.
+    if (typeof raw !== 'string' || raw === '') continue;
+    // Supplied on the command line — argv always wins.
+    if (supplied.has(spec.name)) continue;
+
+    if (spec.kind === 'boolean') {
+      const v = raw.trim().toLowerCase();
+      if (v === '1' || v === 'true' || v === 'yes' || v === 'on') {
+        out.options[spec.name] = true;
+      }
+      continue;
+    }
+    if (spec.kind === 'array') {
+      // Comma-separated, so a single env var can carry a repeatable flag.
+      const items = raw.split(',').map((x) => x.trim()).filter(Boolean);
+      if (items.length > 0) out.options[spec.name] = items;
+      continue;
+    }
+    const { value, error } = coerce(spec, raw);
+    if (error) out.errors.push(`${spec.env}: ${error}`);
+    else out.options[spec.name] = value;
+  }
+}
+
 /**
  * Consume the value(s) for `spec` starting at argv index `i` (where argv[i]
  * is the flag token itself). `inline` is the post-`=` value when present.

package/src/options/spec.js

@@ -17,6 +17,9 @@
 //                   times (occurrences accumulate); array kind also collects
 //                   variadic values until the next flag-looking token.
 //     env:          Optional environment-variable fallback.
+//     printModeOnly: Only forward this flag when running under
+//                   `--print-mode`. For upstream flags that require
+//                   `--print` and abort the process without it.
 //     description:  One-line help text.
 //     forward:      How this option reaches the upstream `claude` process.
 //                     { type: 'argv', flag: '--name' }   pass to spawn argv
@@ -72,7 +75,11 @@ export const OPTION_SPEC = [
   {
     name: 'model',
     kind: 'string',
-    description: 'Model alias or full name (e.g. `sonnet`, `claude-sonnet-4-6`).',
+    description:
+      'Model alias or full name. Aliases resolve to the latest model in ' +
+      'that family (e.g. `fable`, `opus`, `sonnet`, `haiku`); full names ' +
+      'are passed through verbatim (e.g. `claude-opus-5`, ' +
+      '`claude-fable-5-1`, `claude-sonnet-5`).',
     forward: { type: 'argv', flag: '--model' },
   },
   {
@@ -225,6 +232,24 @@ export const OPTION_SPEC = [
       '(stream-json input + output only).',
     forward: { type: 'shim' },
   },
+  {
+    name: 'forward-subagent-text',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Forward subagent text and thinking blocks as assistant/user messages ' +
+      'with `parent_tool_use_id` set. Requires `--output-format=stream-json`.',
+    forward: { type: 'argv', flag: '--forward-subagent-text' },
+  },
+  {
+    name: 'prompt-suggestions',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Emit a `prompt_suggestion` message after each turn carrying a ' +
+      'predicted next user prompt (stream-json output).',
+    forward: { type: 'argv', flag: '--prompt-suggestions' },
+  },
   {
     name: 'include-hook-events',
     kind: 'boolean',
@@ -236,7 +261,18 @@ export const OPTION_SPEC = [
     name: 'include-partial-messages',
     kind: 'boolean',
     default: false,
-    description: 'Include partial assistant message chunks in stream-json output.',
+    // Upstream refuses this flag unless it is also given `--print`
+    // ("Error: --include-partial-messages requires --print and
+    // --output-format=stream-json") and exits immediately. The default
+    // PTY path drives the interactive TUI, so forwarding it there kills
+    // the spawn. ocp already synthesises `assistant-partial` events from
+    // the TUI frames on that path, so the flag has nothing to add there
+    // anyway — it is forwarded only under `--print-mode`.
+    printModeOnly: true,
+    description:
+      'Include partial assistant message chunks in stream-json output. ' +
+      'Forwarded upstream only under `--print-mode`; on the default PTY ' +
+      'path ocp emits `assistant-partial` events itself.',
     forward: { type: 'argv', flag: '--include-partial-messages' },
   },
 
@@ -244,8 +280,11 @@ export const OPTION_SPEC = [
   {
     name: 'effort',
     kind: 'enum',
-    choices: ['low', 'medium', 'high', 'max'],
-    description: 'Effort level the model should apply.',
+    choices: ['low', 'medium', 'high', 'xhigh', 'max'],
+    description:
+      'Effort level the model should apply (`low` | `medium` | `high` | ' +
+      '`xhigh` | `max`). `xhigh` sits between `high` and `max` and is the ' +
+      'upstream default for coding and agentic work.',
     forward: { type: 'argv', flag: '--effort' },
   },
   {
@@ -281,6 +320,14 @@ export const OPTION_SPEC = [
     description: 'API-side task budget in tokens. Shim-enforced.',
     forward: { type: 'shim' },
   },
+  {
+    name: 'autocompact',
+    kind: 'string',
+    description:
+      'Auto-compact window size: `auto`, or an explicit token budget ' +
+      'between 100k and 1M (e.g. `200000`, `500k`).',
+    forward: { type: 'argv', flag: '--autocompact' },
+  },
   {
     name: 'fallback-model',
     kind: 'string',
@@ -293,8 +340,10 @@ export const OPTION_SPEC = [
     name: 'permission-mode',
     kind: 'string',
     description:
-      'Permission mode (`default` | `plan` | `acceptEdits` | ' +
-      '`bypassPermissions` | `dontAsk` | `auto`).',
+      'Permission mode (`acceptEdits` | `auto` | `bypassPermissions` | ' +
+      '`manual` | `dontAsk` | `plan`). `manual` is the current name for ' +
+      "the interactive prompt-on-every-tool mode; upstream still accepts " +
+      'the older `default` spelling, so ocp keeps accepting it too.',
     forward: { type: 'argv', flag: '--permission-mode' },
   },
   {
@@ -305,6 +354,35 @@ export const OPTION_SPEC = [
       'Allow `--dangerously-skip-permissions` as a choice without enabling it.',
     forward: { type: 'argv', flag: '--allow-dangerously-skip-permissions' },
   },
+  {
+    name: 'permission-prompts',
+    kind: 'enum',
+    choices: ['host', 'none'],
+    description:
+      'Who answers permission prompts: `host` (the SDK host, or the tool ' +
+      'named by `--permission-prompt-tool`) or `none` (nobody — anything ' +
+      'that would prompt is denied automatically; the permission mode ' +
+      'still decides everything else). `none` suits PTY automation, which ' +
+      'has no way to answer a prompt, when denying is preferable to ' +
+      'bypassing checks outright.',
+    forward: { type: 'argv', flag: '--permission-prompts' },
+  },
+  {
+    name: 'restricted',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Restricted mode: drop the built-in tools that run commands or code ' +
+      '(Bash, PowerShell, REPL, …) and WebFetch unless `--tools` names ' +
+      'them, ignore user/project/local settings files (managed settings ' +
+      'and `--settings` still apply), confine the file tools to the ' +
+      'working directories, and refuse `bypassPermissions`. Pair with ' +
+      '`--strict-mcp-config` to skip MCP servers too. Note that ocp does ' +
+      'not get its usual clean transcript in this mode — no session ' +
+      'JSONL is written for the run, so the reply is reconstructed from ' +
+      'the TUI frames and may carry leftover box-border chrome.',
+    forward: { type: 'argv', flag: '--restricted' },
+  },
   {
     name: 'tools',
     kind: 'string',
@@ -353,6 +431,29 @@ export const OPTION_SPEC = [
     description: 'Append to the system prompt from a file path.',
     forward: { type: 'argv', flag: '--append-system-prompt-file' },
   },
+  {
+    name: 'system-prompt-snapshot',
+    kind: 'enum',
+    choices: ['on', 'off'],
+    description:
+      'Record the system prompt once per conversation and reuse it ' +
+      'verbatim on every later request and resume (`on`, the upstream ' +
+      'default), or render it fresh every request (`off`, for iterating ' +
+      'on prompt text). With `on`, a later run passing different prompt ' +
+      'text is ignored until the conversation is compacted.',
+    forward: { type: 'argv', flag: '--system-prompt-snapshot' },
+  },
+  {
+    name: 'exclude-dynamic-system-prompt-sections',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Move per-machine sections (cwd, env info, memory paths, git status) ' +
+      'out of the system prompt and into the first user message, so the ' +
+      'cached prompt prefix is identical across machines and users. Ignored ' +
+      'when `--system-prompt` replaces the default prompt.',
+    forward: { type: 'argv', flag: '--exclude-dynamic-system-prompt-sections' },
+  },
   {
     name: 'add-dir',
     kind: 'array',
@@ -387,6 +488,13 @@ export const OPTION_SPEC = [
     description: 'Load plugins from directory (repeatable).',
     forward: { type: 'argv', flag: '--plugin-dir' },
   },
+  {
+    name: 'plugin-url',
+    kind: 'array',
+    repeatable: true,
+    description: 'Fetch a plugin `.zip` from a URL for this session only (repeatable).',
+    forward: { type: 'argv', flag: '--plugin-url' },
+  },
   {
     name: 'disable-slash-commands',
     kind: 'boolean',
@@ -455,6 +563,38 @@ export const OPTION_SPEC = [
     description: 'Run Setup hooks with the `maintenance` trigger, then continue.',
     forward: { type: 'argv', flag: '--maintenance' },
   },
+  {
+    name: 'safe-mode',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Start with all customizations disabled (CLAUDE.md, skills, plugins, ' +
+      'hooks, MCP servers, custom commands and agents, output styles, ' +
+      'workflows, themes, keybindings). Admin policy settings still apply. ' +
+      'Sets `CLAUDE_CODE_SAFE_MODE=1`. Useful for reproducing a failure ' +
+      'without local configuration in the way.',
+    forward: { type: 'argv', flag: '--safe-mode' },
+  },
+  {
+    name: 'ax-screen-reader',
+    kind: 'boolean',
+    default: false,
+    env: 'OCP_AX_SCREEN_READER',
+    description:
+      'Ask the upstream TUI for screen-reader friendly output: flat text, ' +
+      'no decorative borders, no animations. Because ocp reconstructs its ' +
+      'answer by scraping TUI frames, this markedly reduces the amount of ' +
+      'chrome the parsers have to strip. Opt-in — it changes the captured ' +
+      'frame shape, so it is never enabled by default.',
+    forward: { type: 'argv', flag: '--ax-screen-reader' },
+  },
+  {
+    name: 'brief',
+    kind: 'boolean',
+    default: false,
+    description: 'Enable the SendUserMessage tool for agent-to-user communication.',
+    forward: { type: 'argv', flag: '--brief' },
+  },
   {
     name: 'debug-file',
     kind: 'string',

package/src/options/validate.js

@@ -8,8 +8,14 @@
 // Rules are appended to `CROSS_RULES`; the runner returns the concatenated
 // list of human-readable errors.
 
+// Upstream (`claude --permission-mode`) advertises: acceptEdits, auto,
+// bypassPermissions, manual, dontAsk, plan. `manual` is the current name
+// for the prompt-on-every-tool mode that used to be spelled `default`;
+// upstream still accepts `default`, so we keep it here rather than
+// breaking callers that pass it.
 const PERMISSION_MODES = new Set([
-  'default', 'plan', 'acceptEdits', 'bypassPermissions', 'dontAsk', 'auto',
+  'acceptEdits', 'auto', 'bypassPermissions', 'manual', 'dontAsk', 'plan',
+  'default',
 ]);
 
 /** @type {Array<(options: Record<string, unknown>) => string | undefined>} */
@@ -85,6 +91,40 @@ export const CROSS_RULES = [
       return '`--fork-session` requires `--resume <id>` or `--continue`.';
     }
   },
+  // R11. forward-subagent-text => stream-json output. Upstream only emits
+  //      the extra assistant/user messages on the stream-json channel.
+  (o) => {
+    if (o['forward-subagent-text'] === true && o['output-format'] !== 'stream-json') {
+      return '`--forward-subagent-text` requires `--output-format=stream-json`.';
+    }
+  },
+  // R12. prompt-suggestions => stream-json output. The suggestion arrives
+  //      as its own `prompt_suggestion` event; the text and json adapters
+  //      have nowhere to put it.
+  (o) => {
+    if (o['prompt-suggestions'] === true && o['output-format'] !== 'stream-json') {
+      return '`--prompt-suggestions` requires `--output-format=stream-json`.';
+    }
+  },
+  // R13. autocompact takes `auto` or a token budget in the 100k–1M range.
+  //      Accepts a bare integer or a `k`/`m` suffix.
+  (o) => {
+    const v = o.autocompact;
+    if (v === undefined) return undefined;
+    if (typeof v !== 'string' || v === '') {
+      return '`--autocompact` must be `auto` or a token budget between 100k and 1M.';
+    }
+    if (v === 'auto') return undefined;
+    const m = /^(\d+(?:\.\d+)?)([km])?$/i.exec(v.trim());
+    if (!m) {
+      return `\`--autocompact\` must be \`auto\` or a token budget between 100k and 1M; got ${JSON.stringify(v)}.`;
+    }
+    const mult = m[2] ? { k: 1e3, m: 1e6 }[m[2].toLowerCase()] : 1;
+    const tokens = Number(m[1]) * mult;
+    if (!(tokens >= 100_000 && tokens <= 1_000_000)) {
+      return `\`--autocompact\` token budget must be between 100k and 1M; got ${JSON.stringify(v)}.`;
+    }
+  },
 ];
 
 /**

package/src/parsers/ansi-strip.js

@@ -1,8 +1,24 @@
 // Baseline parser: strip ANSI escape sequences.
 //
-// We do not attempt to reconstruct a terminal screen here. Cursor moves,
-// clears, and color codes are simply removed. The remaining text is what
-// downstream parsers consume.
+// We do not attempt to reconstruct a terminal screen here. Colors, clears
+// and vertical moves are simply removed. The one thing we DO model is the
+// cursor's horizontal position, because the upstream TUI uses horizontal
+// moves in place of literal spaces:
+//
+//   A\x1b[5Gpseudoterminal\x1b[20Gis\x1b[23Ga\x1b[25Gsoftware
+//
+// Every inter-word gap there is an absolute column move, not a space. Strip
+// the sequences blindly and the words run together — "Apseudoterminalisa…".
+// So we track the column and translate a forward move into the run of
+// spaces it would have left blank on screen.
+//
+// Two sequences produce those gaps:
+//   CUF — `ESC [ Pn C`  move right Pn columns (relative, default 1)
+//   CHA — `ESC [ Pn G`  move to column Pn    (absolute, 1-based, default 1)
+//
+// CUF alone used to be enough; the current CLI emits CHA for nearly every
+// word, which is what made this worth modelling properly rather than
+// special-casing one sequence.
 //
 // Buffering rule for partial chunks: if the chunk ends with an ESC that has
 // not yet been terminated (e.g. mid-CSI), hold it until the next chunk.
@@ -10,37 +26,9 @@
 const ESC = '\x1b';
 const BEL = '\x07';
 
-// Cursor Forward (CUF): `ESC [ Pn C` advances the cursor `Pn` columns
-// (default 1). In headless captures the upstream `claude` CLI uses this
-// in place of literal space characters for inter-word gaps (a TUI
-// rendering optimization). Stripping the sequence collapses words
-// together — `each<CUF1>other` becomes `eachother`. We translate CUF
-// into the equivalent run of spaces BEFORE the general CSI strip so the
-// visible text is preserved.
-const RE_CSI_CURSOR_FORWARD = /\x1b\[(\d*)C/g;
-function expandCursorForward(text) {
-  return text.replace(RE_CSI_CURSOR_FORWARD, (_match, n) => {
-    const count = parseInt(n || '1', 10);
-    return ' '.repeat(Math.min(count, 200)); // cap defensively
-  });
-}
-
-// Complete-sequence regexes — used only on input slices we have proven to be
-// complete (i.e. without a dangling partial at the end).
-const RE_CSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;       // ESC [ params intermediates final
-// OSC-style sequences: ESC introducer then arbitrary content then BEL or ST.
-// Covers OSC (`]`), DCS (`P`), SOS (`X`), PM (`^`), APC (`_`).
-const RE_STRING_TERMINATED =
-  /\x1b[\]PX^_][^\x07\x1b]*(?:\x07|\x1b\\)/g;
-// Two-byte ESC forms — covers C1 7-bit aliases (`ESC @`..`ESC _` except the
-// CSI/OSC/etc. introducers, which are handled above) AND the DEC private
-// single-letter sequences in the 0x30..0x3F range (`ESC 7` = DECSC save
-// cursor, `ESC 8` = DECRC restore, `ESC =` / `ESC >` keypad modes, etc.).
-// Order is: CSI -> string-terminated -> this, so by the time we reach
-// RE_C1 the only `\x1b[`/`\x1b]`/`\x1b_`/... left in the input is either
-// complete-and-already-stripped or partial-and-held-back by the pending
-// buffer.
-const RE_C1  = /\x1b[0-?@-_]/g;
+// Defensive ceiling on generated padding. A corrupt or hostile column
+// target must not let one escape sequence expand into megabytes.
+const MAX_PAD = 200;
 
 /** Introducer characters for OSC-style sequences (BEL/ST terminated). */
 const STRING_INTRODUCERS = new Set([']', 'P', 'X', '^', '_']);
@@ -56,11 +44,136 @@ function isCompleteEscapeTail(tail) {
   return tail.length >= 2;
 }
 
+/** First numeric parameter of a CSI parameter string, or `fallback`. */
+function firstParam(params, fallback) {
+  const n = parseInt(params, 10);
+  return Number.isNaN(n) ? fallback : n;
+}
+
+/** Nth (0-based) numeric parameter of a CSI parameter string. */
+function nthParam(params, index, fallback) {
+  const raw = params.split(';')[index];
+  if (raw === undefined || raw === '') return fallback;
+  const n = parseInt(raw, 10);
+  return Number.isNaN(n) ? fallback : n;
+}
+
+/**
+ * Strip escapes from `input` while tracking the cursor column, expanding
+ * forward horizontal moves into spaces.
+ *
+ * `state.col` is the 0-based column and persists across chunks, since a
+ * rendered line routinely spans several PTY reads.
+ *
+ * @param {string} input
+ * @param {{col: number}} state
+ * @returns {string}
+ */
+function stripTrackingColumn(input, state) {
+  let out = '';
+  let i = 0;
+  const len = input.length;
+
+  while (i < len) {
+    const ch = input[i];
+
+    if (ch === '\r' || ch === '\n') {
+      out += ch;
+      state.col = 0;
+      i += 1;
+      continue;
+    }
+
+    if (ch !== ESC) {
+      out += ch;
+      state.col += 1;
+      i += 1;
+      continue;
+    }
+
+    const c1 = input[i + 1];
+
+    // ── CSI: ESC [ params intermediates final ────────────────────────────
+    if (c1 === '[') {
+      let j = i + 2;
+      while (j < len) {
+        const c = input.charCodeAt(j);
+        if (c >= 0x30 && c <= 0x3f) j += 1; // parameter bytes
+        else break;
+      }
+      const paramsEnd = j;
+      while (j < len) {
+        const c = input.charCodeAt(j);
+        if (c >= 0x20 && c <= 0x2f) j += 1; // intermediate bytes
+        else break;
+      }
+      if (j >= len) {
+        // Incomplete despite the pending-buffer guard; drop the remainder.
+        break;
+      }
+      const final = input[j];
+      const params = input.slice(i + 2, paramsEnd);
+      i = j + 1;
+
+      // Private-parameter sequences (`ESC [ ? 25 h`) never move the cursor
+      // horizontally in a way we can model; strip them.
+      if (params.charCodeAt(0) >= 0x3c && params.charCodeAt(0) <= 0x3f) continue;
+
+      if (final === 'C') {
+        // CUF — relative forward move.
+        const n = Math.max(0, firstParam(params, 1));
+        const pad = Math.min(n, MAX_PAD);
+        out += ' '.repeat(pad);
+        state.col += pad;
+      } else if (final === 'G' || final === '`') {
+        // CHA / HPA — absolute column, 1-based.
+        const target = Math.max(1, firstParam(params, 1)) - 1;
+        if (target > state.col) {
+          const pad = Math.min(target - state.col, MAX_PAD);
+          out += ' '.repeat(pad);
+          state.col += pad;
+        }
+        // A backwards move would overwrite already-emitted text. We cannot
+        // represent that without a screen model, so we neither pad nor
+        // rewind — the text simply continues.
+      } else if (final === 'H' || final === 'f') {
+        // CUP — absolute row;col. This is a jump to another part of the
+        // screen (status line, input box), so it never means "gap here";
+        // adopt the column but emit no padding.
+        state.col = Math.max(1, nthParam(params, 1, 1)) - 1;
+      }
+      // Everything else (SGR, erase, vertical moves, scroll regions) is
+      // zero-width for our purposes: stripped, column untouched.
+      continue;
+    }
+
+    // ── OSC and friends: ESC ] … BEL | ST ────────────────────────────────
+    if (STRING_INTRODUCERS.has(c1)) {
+      let j = i + 2;
+      while (j < len) {
+        if (input[j] === BEL) { j += 1; break; }
+        if (input[j] === ESC && input[j + 1] === '\\') { j += 2; break; }
+        j += 1;
+      }
+      i = j;
+      continue;
+    }
+
+    // ── Two-byte ESC forms (ESC 7, ESC 8, ESC =, C1 aliases) ─────────────
+    if (c1 === undefined) break; // dangling ESC; pending guard should catch it
+    i += 2;
+  }
+
+  return out;
+}
+
 export const ansiStripParser = {
   name: 'ansi-strip',
   priority: 10,
   create() {
     let pending = '';
+    // Cursor column persists across feeds — a line spans many PTY reads.
+    const state = { col: 0 };
     return {
       feed(chunk) {
         let input = pending + chunk;
@@ -77,17 +190,11 @@ export const ansiStripParser = {
           }
         }
 
-        // Translate visible-gap CSI sequences (cursor forward) into
-        // literal spaces BEFORE the general CSI strip eats them.
-        const expanded = expandCursorForward(input);
-        const out = expanded
-          .replace(RE_CSI, '')
-          .replace(RE_STRING_TERMINATED, '')
-          .replace(RE_C1, '');
-        return { text: out, events: [] };
+        return { text: stripTrackingColumn(input, state), events: [] };
       },
       reset() {
         pending = '';
+        state.col = 0;
       },
     };
   },