carthagent 1.0.7 → 1.1.0-beta.1

package/tests/server.test.mjs

@@ -79,7 +79,9 @@ test('dashboard status reports an available update from the release cache', asyn
   // Seed the throttled cache so the check resolves without touching the network.
   const cachePath = join(dir, 'update-check.json');
   writeFileSync(cachePath, JSON.stringify({ checkedAt: Date.now(), release: { version: '99.0.0', tag: 'v99.0.0' } }));
-  const server = await serverFixture(t, { CARTHAGENT_UPDATE_CHECK_FILE: cachePath });
+  const channelPath = join(dir, 'update-channel.json');
+  writeFileSync(channelPath, JSON.stringify({ version: 1, channel: 'stable' }));
+  const server = await serverFixture(t, { CARTHAGENT_UPDATE_CHECK_FILE: cachePath, CARTHAGENT_UPDATE_CHANNEL_FILE: channelPath });
   let body = {};
   for (let i = 0; i < 50 && !body.update; i++) {
     body = await (await fetch(`${server.url}/api/status`, { headers: { 'x-carthagent-token': server.token } })).json();

package/tests/ship-telemetry.test.mjs

@@ -234,7 +234,7 @@ test('update check sends the install headers to the control plane only', async t
   const agentDir = tmp(t);
   const seen = [];
   const { release, source } = await fetchLatestRelease({
-    cloudUrl: 'https://cloud.test', env: {}, agentDir,
+    cloudUrl: 'https://cloud.test', env: {}, agentDir, channel: 'stable',
     fetchImpl: async (url, options) => {
       seen.push({ url, headers: options.headers });
       if (url.includes('/v1/cli/releases/latest')) return { status: 503, json: async () => ({}) };

package/tests/source-preview.test.mjs

@@ -0,0 +1,253 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = fileURLToPath(new URL('..', import.meta.url));
+const launcher = join(root, 'script/ctg/source-preview.sh');
+const plugin = join(root, 'plugins/carthagent');
+
+function fixture(t, { bunVersion = '1.4.2' } = {}) {
+  // Reach the fixture through a symlinked parent, like macOS /var -> /private/var, so explicit
+  // alias spellings and physical cwd resolution stay distinguishable on every POSIX host.
+  const physicalParent = mkdtempSync(join(tmpdir(), 'ctg preview physical '));
+  const aliasParent = mkdtempSync(join(tmpdir(), 'ctg preview alias '));
+  t.after(() => {
+    rmSync(aliasParent, { recursive: true, force: true });
+    rmSync(physicalParent, { recursive: true, force: true });
+  });
+  symlinkSync(physicalParent, join(aliasParent, 'var'));
+  const base = join(aliasParent, 'var');
+  assert.notEqual(realpathSync(base), base, 'fixture base must be reached through an alias');
+  const source = join(base, 'native source');
+  mkdirSync(join(source, 'packages/cli/src'), { recursive: true });
+  mkdirSync(join(source, 'node_modules'));
+  writeFileSync(join(source, 'package.json'), JSON.stringify({ name: 'opencode', packageManager: 'bun@1.4.2' }));
+  writeFileSync(join(source, 'packages/cli/src/index.ts'), '');
+  const tools = join(base, 'tool dir');
+  mkdirSync(tools);
+  const record = join(base, 'record.json');
+  const bun = join(tools, 'bun');
+  // Test double: reports version, or records invocation cwd/args/env instead of running OpenCode.
+  writeFileSync(bun, `#!/bin/sh
+if [ "$1" = "--version" ]; then echo ${bunVersion}; exit 0; fi
+exec "${process.execPath}" -e 'require("node:fs").writeFileSync(process.argv[1], JSON.stringify({ cwd: process.cwd(), args: process.argv.slice(2), env: process.env }))' "${record}" "$@"
+`);
+  chmodSync(bun, 0o755);
+  const profile = join(base, 'private profile');
+  const workspace = join(base, 'empty workspace');
+  mkdirSync(workspace);
+  const outside = join(base, 'outside cwd');
+  mkdirSync(outside);
+  return { base, source, bun, profile, workspace, outside, record };
+}
+
+// The launcher is a POSIX /bin/sh script; native Windows has no /bin/sh and is not a supported platform.
+const posixOnly = process.platform === 'win32' ? 'POSIX /bin/sh launcher is not supported on native Windows' : false;
+const posixTest = (name, fn) => test(name, { skip: posixOnly }, fn);
+
+function sh(script, args, options) {
+  const result = spawnSync('/bin/sh', [script, ...args], { encoding: 'utf8', ...options });
+  if (result.error) throw new Error(`could not run /bin/sh ${script}: ${result.error.message}`, { cause: result.error });
+  return result;
+}
+
+function run(f, args, { env = {}, cwd = f.outside } = {}) {
+  const result = sh(launcher, args, { cwd, env: { PATH: '/usr/bin:/bin', TERM: 'xterm-256color', ...env } });
+  const recorded = existsSync(f.record) ? JSON.parse(readFileSync(f.record, 'utf8')) : undefined;
+  return { ...result, recorded };
+}
+
+const required = f => ['--source', f.source, '--profile', f.profile, '--bun', f.bun];
+
+posixTest('launches source CLI from packages/cli with explicit space-containing paths outside the repository', t => {
+  const f = fixture(t);
+  const result = run(f, [...required(f), '--workspace', f.workspace]);
+  assert.equal(result.status, 0, result.stderr);
+  // process.cwd() always reports the physical directory, even when entered through an alias.
+  assert.equal(result.recorded.cwd, join(realpathSync(f.source), 'packages/cli'));
+  assert.deepEqual(result.recorded.args, ['--no-env-file', 'run', 'src/index.ts', '--standalone', f.workspace]);
+  assert.equal(result.recorded.env.HOME, join(f.profile, 'home'));
+});
+
+posixTest('defaults the workspace to the caller directory and resolves relative paths against it', t => {
+  const f = fixture(t);
+  // The spawned caller has no inherited PWD, so its shell resolves the default and relative paths from the physical cwd.
+  let result = run(f, required(f), { cwd: f.workspace });
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(result.recorded.args.slice(-2), ['--standalone', realpathSync(f.workspace)]);
+  rmSync(f.record);
+  const callerBase = realpathSync(f.base);
+  result = run(f, ['--source', 'native source', '--profile', 'private profile', '--bun', 'tool dir/bun', '--workspace', 'empty workspace'], { cwd: f.base });
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.recorded.cwd, join(callerBase, 'native source/packages/cli'));
+  assert.deepEqual(result.recorded.args.slice(-2), ['--standalone', join(callerBase, 'empty workspace')]);
+  assert.equal(result.recorded.env.HOME, join(callerBase, 'private profile/home'));
+});
+
+posixTest('passes only the isolated allowlist and never inherits credentials', t => {
+  const f = fixture(t);
+  const result = run(f, [...required(f), '--workspace', f.workspace], {
+    env: { OPENAI_API_KEY: 'synthetic-not-a-secret', ANTHROPIC_API_KEY: 'synthetic', OPENCODE_CONFIG: '/elsewhere', HOME: '/home/ordinary', XDG_CONFIG_HOME: '/home/ordinary/.config', COLORTERM: 'truecolor' },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  const env = result.recorded.env;
+  for (const name of ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'OPENCODE_CONFIG']) assert.equal(env[name], undefined, name);
+  assert.equal(env.HOME, join(f.profile, 'home'));
+  assert.equal(env.TMPDIR, join(f.profile, 'tmp'));
+  assert.equal(env.XDG_CONFIG_HOME, join(f.profile, 'config'));
+  assert.equal(env.XDG_DATA_HOME, join(f.profile, 'data'));
+  assert.equal(env.XDG_CACHE_HOME, join(f.profile, 'cache'));
+  assert.equal(env.XDG_STATE_HOME, join(f.profile, 'state'));
+  assert.equal(env.OPENCODE_CONFIG_DIR, join(f.profile, 'config/opencode'));
+  assert.equal(env.OPENCODE_TEST_HOME, join(f.profile, 'home'));
+  assert.equal(env.OPENCODE_DISABLE_PROJECT_CONFIG, '1');
+  assert.equal(env.OPENCODE_DISABLE_AUTOUPDATE, '1');
+  assert.equal(env.BUN_RUNTIME_TRANSPILER_CACHE_PATH, '0');
+  assert.equal(env.TERM, 'xterm-256color');
+  assert.equal(env.COLORTERM, 'truecolor');
+  assert.equal(env.PATH.split(':')[0], join(f.base, 'tool dir'));
+});
+
+posixTest('creates a private profile with plugin, theme and CLI configuration on first launch', t => {
+  const f = fixture(t);
+  const result = run(f, [...required(f), '--workspace', f.workspace]);
+  assert.equal(result.status, 0, result.stderr);
+  const config = join(f.profile, 'config/opencode');
+  assert.deepEqual(JSON.parse(readFileSync(join(config, 'opencode.json'), 'utf8')).plugins, [plugin]);
+  assert.equal(JSON.parse(readFileSync(join(config, 'cli.json'), 'utf8')).theme.name, 'carthage');
+  assert.equal(readFileSync(join(config, 'themes/carthage.json'), 'utf8'), readFileSync(join(plugin, 'themes/carthage.json'), 'utf8'));
+  assert.equal(statSync(f.profile).mode & 0o777, 0o700);
+  assert.equal(statSync(join(config, 'opencode.json')).mode & 0o777, 0o600);
+  for (const dir of ['home', 'tmp', 'data', 'cache', 'state']) assert.ok(statSync(join(f.profile, dir)).isDirectory(), dir);
+});
+
+posixTest('creates the private profile with BSD chmod argument parsing and a dash-leading relative path', t => {
+  const f = fixture(t);
+  const shims = join(f.base, 'bsd shims');
+  mkdirSync(shims);
+  // BSD chmod stops option parsing at the mode, so a later `--` is a missing file operand.
+  writeFileSync(join(shims, 'chmod'), `#!/bin/sh
+mode=$1; shift
+for operand in "$@"; do
+  case "$operand" in --|-*) echo "chmod: $operand: No such file or directory" >&2; exit 1 ;; esac
+done
+exec /bin/chmod "$mode" "$@"
+`);
+  chmodSync(join(shims, 'chmod'), 0o755);
+  const result = run(f, ['--source', f.source, '--profile', '-dash profile', '--bun', f.bun, '--workspace', f.workspace], {
+    cwd: f.base, env: { PATH: `${shims}:/usr/bin:/bin` },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  const profile = join(f.base, '-dash profile');
+  assert.equal(statSync(profile).mode & 0o777, 0o700);
+  assert.equal(result.recorded.env.HOME, join(realpathSync(f.base), '-dash profile/home'));
+  assert.ok(existsSync(join(profile, 'config/opencode/opencode.json')));
+});
+
+posixTest('preserves existing profile configuration and authentication on repeat launches', t => {
+  const f = fixture(t);
+  const config = join(f.profile, 'config/opencode');
+  mkdirSync(join(config, 'themes'), { recursive: true });
+  mkdirSync(join(f.profile, 'data/opencode'), { recursive: true });
+  const files = {
+    [join(config, 'opencode.json')]: JSON.stringify({ plugins: [plugin], provider: { synthetic: { options: { baseURL: 'http://127.0.0.1:1' } } } }),
+    [join(config, 'cli.json')]: JSON.stringify({ theme: { name: 'nord', mode: 'light' } }),
+    [join(config, 'themes/carthage.json')]: '{"synthetic":"user theme"}',
+    [join(f.profile, 'data/opencode/auth.json')]: '{"synthetic":"fixture, not a credential"}',
+  };
+  for (const [path, content] of Object.entries(files)) writeFileSync(path, content);
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const result = run(f, [...required(f), '--workspace', f.workspace]);
+    assert.equal(result.status, 0, result.stderr);
+    for (const [path, content] of Object.entries(files)) assert.equal(readFileSync(path, 'utf8'), content, path);
+  }
+});
+
+posixTest('warns without rewriting a supplied config that omits the Carthagent plugin', t => {
+  const f = fixture(t);
+  const config = join(f.profile, 'config/opencode');
+  mkdirSync(config, { recursive: true });
+  writeFileSync(join(config, 'opencode.json'), '{"plugins":[]}');
+  const result = run(f, [...required(f), '--workspace', f.workspace]);
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stderr, /does not reference the Carthagent plugin/);
+  assert.equal(readFileSync(join(config, 'opencode.json'), 'utf8'), '{"plugins":[]}');
+});
+
+posixTest('accepts a config that references the plugin through its physical path when launched via an alias', t => {
+  const f = fixture(t);
+  const alias = join(f.base, 'checkout alias');
+  symlinkSync(root, alias);
+  const config = join(f.profile, 'config/opencode');
+  mkdirSync(config, { recursive: true });
+  writeFileSync(join(config, 'opencode.json'), JSON.stringify({ plugins: [plugin] }));
+  const result = sh(join(alias, 'script/ctg/source-preview.sh'), [...required(f), '--workspace', f.workspace], {
+    cwd: f.outside, env: { PATH: '/usr/bin:/bin' },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  assert.doesNotMatch(result.stderr, /warning/);
+});
+
+posixTest('forwards explicit commands after -- and enforces a private standalone server', t => {
+  const f = fixture(t);
+  let result = run(f, [...required(f), '--', 'auth', 'login', 'my provider']);
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(result.recorded.args, ['--no-env-file', 'run', 'src/index.ts', 'auth', 'login', 'my provider', '--standalone']);
+  rmSync(f.record);
+  result = run(f, [...required(f), '--', '--standalone', f.workspace]);
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(result.recorded.args.slice(3), ['--standalone', f.workspace]);
+  for (const forbidden of [['--server', 'http://127.0.0.1:4096'], ['--server=http://127.0.0.1:4096']]) {
+    rmSync(f.record, { force: true });
+    result = run(f, [...required(f), '--', ...forbidden]);
+    assert.equal(result.status, 2);
+    assert.match(result.stderr, /--server/);
+    assert.equal(result.recorded, undefined);
+  }
+});
+
+posixTest('reports missing explicit inputs and prerequisites without launching', t => {
+  const f = fixture(t);
+  const cases = [
+    [['--profile', f.profile, '--bun', f.bun], /--source is required/],
+    [['--source', f.source, '--bun', f.bun], /--profile is required/],
+    [['--source', f.source, '--profile', f.profile], /--bun is required/],
+    [['--source', join(f.base, 'missing'), '--profile', f.profile, '--bun', f.bun], /source .* is not a directory/],
+    [['--source', f.workspace, '--profile', f.profile, '--bun', f.bun], /packages\/cli\/src\/index\.ts/],
+    [['--source', f.source, '--profile', f.profile, '--bun', join(f.base, 'missing bun')], /not executable/],
+    [[...required(f), '--workspace', join(f.base, 'missing workspace')], /workspace .* is not a directory/],
+    [[...required(f), '--unknown'], /Unknown option/],
+  ];
+  for (const [args, message] of cases) {
+    const result = run(f, args);
+    assert.equal(result.status, 2, `${args.join(' ')}\n${result.stderr}`);
+    assert.match(result.stderr, message);
+    assert.equal(result.recorded, undefined);
+  }
+  rmSync(join(f.source, 'node_modules'), { recursive: true });
+  const missingDeps = run(f, required(f));
+  assert.equal(missingDeps.status, 1);
+  assert.match(missingDeps.stderr, /bun install/);
+  assert.equal(missingDeps.recorded, undefined);
+  assert.equal(existsSync(f.profile), false, 'failed prerequisite checks do not create a profile');
+});
+
+posixTest('rejects a Bun version that differs from the source packageManager pin', t => {
+  const f = fixture(t, { bunVersion: '1.3.0' });
+  const result = run(f, required(f));
+  assert.equal(result.status, 1);
+  assert.match(result.stderr, /requires bun 1\.4\.2; .* reports 1\.3\.0/);
+  assert.equal(result.recorded, undefined);
+});
+
+posixTest('prints usage with --help', t => {
+  const result = sh(launcher, ['--help'], { env: { PATH: '/usr/bin:/bin' } });
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /--source DIR/);
+  assert.match(result.stdout, /--profile DIR/);
+  assert.match(result.stdout, /--bun PATH/);
+});

package/tests/test_native_terminal_probe.py

@@ -0,0 +1,76 @@
+import importlib.util
+import pathlib
+import unittest
+
+
+MODULE_PATH = pathlib.Path(__file__).resolve().parents[1] / "tools" / "test-native-terminal-performance.py"
+SPEC = importlib.util.spec_from_file_location("native_terminal_probe", MODULE_PATH)
+PROBE = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(PROBE)
+
+
+class EditorEchoTests(unittest.TestCase):
+    def test_native_placeholder_anchor_and_exact_changed_cell_are_required(self):
+        screen = PROBE.Screen(rows=4, cols=40)
+        row, col = 2, 5
+        line = PROBE.NATIVE_EDITOR_PLACEHOLDER
+        for offset, char in enumerate(line):
+            screen.cells[row][col + offset] = char
+        before = [cells[:] for cells in screen.cells]
+        self.assertEqual(PROBE.locate_text(screen, line), (row, col))
+        screen.cells[row][col] = "z"
+        self.assertTrue(PROBE.editor_contains_typed_cell(screen, "z", before, row, col))
+
+    def test_arbitrary_transcript_or_another_editor_cell_is_not_an_echo(self):
+        screen = PROBE.Screen(rows=4, cols=40)
+        row, col = 2, 5
+        for offset, char in enumerate(PROBE.NATIVE_EDITOR_PLACEHOLDER):
+            screen.cells[row][col + offset] = char
+        before = [cells[:] for cells in screen.cells]
+        screen.cells[row][col + 4] = "z"
+        self.assertFalse(PROBE.editor_contains_typed_cell(screen, "z", before, row, col))
+        screen.cells[row][col + 4] = before[row][col + 4]
+        screen.cells[0][0] = "z"
+        self.assertFalse(PROBE.editor_contains_typed_cell(screen, "z", before, row, col))
+
+    def test_pty_ready_detection_uses_the_actual_current_product_hint(self):
+        screen = PROBE.Screen(rows=4, cols=80)
+        hint = "Message carthagent…"
+        for offset, char in enumerate(hint):
+            screen.cells[2][5 + offset] = char
+        self.assertEqual(PROBE.locate_text(screen, PROBE.NATIVE_EDITOR_PLACEHOLDER), (2, 5))
+        self.assertNotEqual(PROBE.NATIVE_EDITOR_PLACEHOLDER, "Ask anything")
+
+    def test_workspace_render_requires_fresh_post_submit_route_and_loaded_section(self):
+        screen = PROBE.Screen(rows=5, cols=80)
+        screen.cells[1][2:25] = list("CARTHAGENT · WORKSPACE")
+        before = ["old session", "slash autocomplete /ctg-workspace", "", "", ""]
+        screen.cells[3][2:26] = list("Workspace native sessions")
+        self.assertTrue(PROBE.workspace_render_completed(screen, before))
+
+    def test_workspace_render_rejects_blank_partial_and_stale_frames(self):
+        screen = PROBE.Screen(rows=5, cols=80)
+        before = ["old session", "", "", "", ""]
+        screen.cells[1][2:25] = list("CARTHAGENT · WORKSPACE")
+        self.assertFalse(PROBE.workspace_render_completed(screen, before))
+        screen.cells[3][2:26] = list("Workspace native sessions")
+        stale = ["", "CARTHAGENT · WORKSPACE", "", "Workspace native sessions", ""]
+        self.assertFalse(PROBE.workspace_render_completed(screen, stale))
+
+    def test_workspace_command_is_not_timed_while_completion_or_old_editor_is_visible(self):
+        screen = PROBE.Screen(rows=5, cols=80)
+        origin = (1, 2)
+        screen.cells[0][20:34] = list("/ctg-workspace")
+        screen.cells[2][2:20] = list("Carthagent commands")
+        self.assertFalse(PROBE.workspace_command_staged(screen, origin))
+        screen.cells[2][2:20] = list("                  ")
+        screen.cells[3][2:20] = list(PROBE.NATIVE_EDITOR_PLACEHOLDER)
+        self.assertFalse(PROBE.workspace_command_staged(screen, origin))
+        screen.cells[3][2:20] = list("                  ")
+        self.assertFalse(PROBE.workspace_command_staged(screen, origin))
+        screen.cells[1][2:16] = list("/ctg-workspace")
+        self.assertTrue(PROBE.workspace_command_staged(screen, origin))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_native_terminal_semantics.py

@@ -0,0 +1,232 @@
+import ast
+import hashlib
+import importlib.util
+import os
+import pathlib
+import subprocess
+import sys
+import time
+import unittest
+from unittest.mock import Mock, patch
+
+
+PTY_AVAILABLE = False
+PROBE = None
+if os.name == 'posix':
+    try:
+        import fcntl
+        import pty
+        import tty
+    except ImportError:
+        pass
+    else:
+        PTY_AVAILABLE = hasattr(os, 'openpty')
+
+if PTY_AVAILABLE:
+    MODULE_PATH = pathlib.Path(__file__).resolve().parents[1] / 'tools' / 'native-terminal-semantics.py'
+    SPEC = importlib.util.spec_from_file_location('native_terminal_semantics', MODULE_PATH)
+    PROBE = importlib.util.module_from_spec(SPEC)
+    SPEC.loader.exec_module(PROBE)
+
+
+@unittest.skipUnless(PTY_AVAILABLE, 'requires POSIX fcntl, pty, tty and os.openpty')
+class DuplexTransportTests(unittest.TestCase):
+    def assert_flags_restored(self, master, flags):
+        restored = fcntl.fcntl(master, fcntl.F_GETFL)
+        # XNU fcntl.h: FWASWRITTEN (0x10000) records successful writes;
+        # sys_generic.c sets it, and kern_descrip.c F_SETFL preserves it
+        # outside FCNTLFLAGS. It is not O_LARGEFILE or a controllable flag.
+        # Compare every other bit, including access mode and O_NONBLOCK.
+        kernel_write_history = 0x10000 if sys.platform == 'darwin' else 0
+        self.assertEqual(restored & ~kernel_write_history, flags & ~kernel_write_history)
+        self.assertEqual(os.get_blocking(master), not bool(flags & os.O_NONBLOCK))
+
+    def launch(self, program):
+        master, slave = pty.openpty()
+        tty.setraw(slave)
+        child = subprocess.Popen([sys.executable, '-u', '-c', program],
+                                 stdin=slave, stdout=slave, stderr=slave)
+        os.close(slave)
+        self.addCleanup(os.close, master)
+
+        def stop():
+            if child.poll() is None:
+                child.kill()
+            child.wait(timeout=3)
+
+        self.addCleanup(stop)
+        return master, child
+
+    def test_large_input_drains_output_and_preserves_every_byte(self):
+        payload = b'\x1b[200~' + ('café 日本語 😀\n' * 20000).encode() + b'\x1b[201~'
+        # The child deliberately fills output BEFORE consuming any input. A
+        # write-only parent deadlocks once the independent PTY queues fill.
+        master, child = self.launch(f'''
+import hashlib, os, time
+block = b'O' * 4096
+for _ in range(128):
+    os.write(1, block)
+data = bytearray()
+while len(data) < {len(payload)}:
+    data.extend(os.read(0, min(4096, {len(payload)} - len(data))))
+os.write(1, b'\\nDIGEST:' + hashlib.sha256(data).hexdigest().encode() + b'\\n')
+time.sleep(2)
+''')
+        flags = fcntl.fcntl(master, fcntl.F_GETFL)
+        output = bytearray()
+        original_write = os.write
+        counts = []
+        retries = [InterruptedError(), BlockingIOError()]
+
+        def partial_write(fd, data):
+            if retries:
+                raise retries.pop()
+            # Force short writes independently of the kernel's queue sizing.
+            count = original_write(fd, data[:997])
+            counts.append(count)
+            return count
+
+        deadline = time.monotonic() + 5
+        with patch.object(PROBE.os, 'write', side_effect=partial_write):
+            PROBE.write_pty_input(master, payload, deadline, output.extend, child)
+        self.assert_flags_restored(master, flags)
+        self.assertEqual(sum(counts), len(payload))
+        self.assertGreater(len(counts), 1)
+        self.assertIn(b'O' * 4096, output)
+        expected = b'DIGEST:' + hashlib.sha256(payload).hexdigest().encode()
+        while expected not in output and time.monotonic() < deadline:
+            if PROBE.select.select([master], [], [], .05)[0]:
+                output.extend(os.read(master, 65536))
+        self.assertIn(expected, output)
+
+    def test_unconsumed_input_times_out_and_restores_flags(self):
+        master, child = self.launch('import time; time.sleep(10)')
+        flags = fcntl.fcntl(master, fcntl.F_GETFL)
+        started = time.monotonic()
+        with self.assertRaisesRegex(TimeoutError, r'bytes written; child status=None'):
+            PROBE.write_pty_input(master, b'x' * 1000000, started + .2, lambda _: None, child)
+        self.assertLess(time.monotonic() - started, 1.5)
+        self.assert_flags_restored(master, flags)
+
+    def test_exited_child_fails_without_waiting_for_deadline(self):
+        master, child = self.launch('pass')
+        child.wait(timeout=3)
+        with self.assertRaisesRegex(RuntimeError, 'exited during PTY input'):
+            PROBE.write_pty_input(master, b'x', time.monotonic() + 5, lambda _: None, child)
+
+    def test_output_callback_failure_restores_flags(self):
+        master, child = self.launch("import os, time; os.write(1, b'ready'); time.sleep(10)")
+        flags = fcntl.fcntl(master, fcntl.F_GETFL)
+
+        def reject_output(_chunk):
+            raise ValueError('screen rejected output')
+
+        with self.assertRaisesRegex(ValueError, 'screen rejected output'):
+            PROBE.write_pty_input(master, b'x' * 1000000, time.monotonic() + 2,
+                                  reject_output, child)
+        self.assert_flags_restored(master, flags)
+
+    def test_initially_nonblocking_descriptor_stays_nonblocking(self):
+        master, child = self.launch('import time; time.sleep(10)')
+        os.set_blocking(master, False)
+        flags = fcntl.fcntl(master, fcntl.F_GETFL)
+        PROBE.write_pty_input(master, b'x', time.monotonic() + 2, lambda _: None, child)
+        self.assert_flags_restored(master, flags)
+
+
+@unittest.skipUnless(PTY_AVAILABLE, 'requires POSIX probe imports')
+class SnapshotTests(unittest.TestCase):
+    def test_utf8_sync_and_queries_survive_every_chunk_boundary(self):
+        payload = b'\x1b[?2026h' + 'café 日本語 😀'.encode() + b'\x1b[6n\x1b[c\x1b[?2026l'
+        for boundary in range(len(payload) + 1):
+            with self.subTest(boundary=boundary):
+                screen = PROBE.Screen()
+                screen.feed(payload[:boundary])
+                screen.feed(payload[boundary:])
+                self.assertFalse(screen.sync_open)
+                self.assertEqual(screen.mode, 'text')
+                self.assertIn('café 日本語 😀', screen.visible())
+                self.assertEqual(screen.queries, [b'\x1b[1;1R', b'\x1b[?1;2c'])
+
+    def test_backlogged_paint_is_consumed_and_all_queries_answered_before_snapshot(self):
+        screen = PROBE.Screen()
+        screen.feed(b'\x1b[?2026hSearch sessions and projects\x1b[6')
+        chunks = [b'n\x1b[', b'c\x1b[2Jshift+tab agents  ctrl+p commands\x1b[?2026', b'l']
+        child = Mock(returncode=None)
+        child.poll.return_value = None
+        replies = []
+        # select times out once mid-frame: no partial snapshot may escape.
+        with patch.object(PROBE.select, 'select', side_effect=[([], [], []),
+                          ([123], [], []), ([123], [], []), ([123], [], []), ([], [], [])]), \
+             patch.object(PROBE.os, 'read', side_effect=chunks):
+            PROBE.drain_terminal_snapshot(123, screen, time.monotonic() + 2,
+                                          screen.feed, replies.append, child)
+        self.assertFalse(screen.sync_open)
+        self.assertNotIn('sessions and projects', screen.visible())
+        self.assertIn('ctrl+p commands', screen.visible())
+        self.assertEqual(replies, [b'\x1b[1;1R', b'\x1b[?1;2c'])
+        self.assertEqual(screen.queries, [])
+
+    def test_unfinished_frame_and_continuous_backlog_obey_existing_deadline(self):
+        for incomplete in (False, True):
+            with self.subTest(incomplete=incomplete):
+                screen = PROBE.Screen()
+                if incomplete:
+                    screen.feed(b'\x1b[?2026h')
+                child = Mock(returncode=None)
+                child.poll.return_value = None
+                with patch.object(PROBE.time, 'monotonic', side_effect=[1, 2, 3]), \
+                     patch.object(PROBE.select, 'select', return_value=([123], [], [])), \
+                     patch.object(PROBE.os, 'read', return_value=b'x'):
+                    with self.assertRaisesRegex(TimeoutError, 'existing input deadline'):
+                        PROBE.drain_terminal_snapshot(123, screen, 3, screen.feed, Mock(), child)
+
+
+@unittest.skipUnless(PTY_AVAILABLE, 'requires POSIX probe imports')
+class PickerSequencingTests(unittest.TestCase):
+    def test_pending_acceptance_prevents_resize_and_paste_with_stale_home_footer(self):
+        # Execute the actual prompt phase from main, not a duplicate predicate.
+        # A slow startup (>5s) leaves the home footer visible behind the picker
+        # in the same iteration that Escape marks its acceptance PENDING.
+        tree = ast.parse(MODULE_PATH.read_text(encoding='utf8'))
+        phases = [node for node in ast.walk(tree) if isinstance(node, ast.If) and
+                  isinstance(node.test, ast.BoolOp) and
+                  [ast.unparse(value) for value in node.test.values[:2]] ==
+                  ['not sent', 'not picker_only']]
+        self.assertEqual(len(phases), 1)
+        phase = compile(ast.Module(body=phases, type_ignores=[]), str(MODULE_PATH), 'exec')
+        for status in ('PENDING', 'PASS', 'FAIL', 'UNSUPPORTED'):
+            with self.subTest(status=status):
+                screen = PROBE.Screen()
+                screen.feed(b'shift+tab agents  ctrl+p commands')
+                payload = ('native-pty: café 日本語 😀\n' + 'large-paste-λ-' * 1200 +
+                           '\nEND-PASTE-終').encode('utf8')
+                write_input = Mock()
+                namespace = dict(sent=False, picker_only=False, focused_case=False,
+                                 picker_cancelled=True, elapsed=6, home_ready=True,
+                                 result={'checks': {'pickerEscapeCancel': {'status': status}}},
+                                 args=Mock(focused_host_roundtrip=False), layout_only=False,
+                                 resize_case=True, screen=screen, output=bytearray(),
+                                 master=123, child=Mock(pid=456), payload=payload,
+                                 write_input=write_input, fcntl=Mock(), termios=PROBE.termios,
+                                 struct=PROBE.struct, os=Mock(), signal=PROBE.signal,
+                                 time=Mock())
+                exec(phase, namespace)
+                if status == 'PENDING':
+                    namespace['fcntl'].ioctl.assert_not_called()
+                    namespace['os'].kill.assert_not_called()
+                    write_input.assert_not_called()
+                    self.assertEqual((screen.rows, screen.columns), (32, 100))
+                    self.assertIn('ctrl+p commands', screen.visible())
+                    self.assertFalse(namespace['sent'])
+                else:
+                    namespace['fcntl'].ioctl.assert_called_once()
+                    namespace['os'].kill.assert_called_once_with(456, PROBE.signal.SIGWINCH)
+                    write_input.assert_called_once_with(b'\x1b[200~' + payload + b'\x1b[201~')
+                    self.assertEqual(len(payload), 18047)
+                    self.assertEqual((screen.rows, screen.columns), (12, 40))
+                    self.assertTrue(namespace['sent'])
+                self.assertEqual(namespace['result']['checks']['pickerEscapeCancel']['status'], status)
+
+if __name__ == '__main__':
+    unittest.main()