carthagent 1.0.7 → 1.1.0-preview.12

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()

package/tests/update.test.mjs

@@ -10,6 +10,7 @@ import {
   fetchLatestRelease,
   latestReleaseCached,
   normalizeRelease,
+  npmInstallSpec,
   staleGlobalInstallPaths,
   updateCheckEnabled,
 } from '../lib/update.mjs';
@@ -82,6 +83,16 @@ test('normalizeRelease rejects install specs that do not install the release tag
   assert.equal(normalizeRelease(manifest).installSpec, 'github:B-icy/Carthagent#v0.3.0');
 });
 
+test('normalizeRelease binds the install ref exactly to the validated version', () => {
+  for (const tag of ['main', 'v0.3.1', 'v0.3.0%2Fmain', ' v0.3.0', 'v0.3.0\n']) {
+    assert.equal(normalizeRelease({ version: '0.3.0', tag }), null, `rejected tag ${JSON.stringify(tag)}`);
+  }
+  assert.equal(normalizeRelease({ version: '1.2.3-beta.2', tag_name: 'v1.2.3-beta.2' })?.installSpec,
+    'github:B-icy/Carthagent#v1.2.3-beta.2');
+  assert.equal(normalizeRelease({ version: '1.2.3-beta.2', tag_name: 'v1.2.3' }), null);
+  assert.equal(normalizeRelease({ version: '01.2.3', tag: 'v01.2.3' }), null);
+});
+
 test('fetchLatestRelease falls back to GitHub when the manifest fails validation', async () => {
   // A control-plane 200 whose installSpec is rejected must not dead-end the
   // update — the GitHub release still resolves.
@@ -100,6 +111,22 @@ test('fetchLatestRelease falls back to GitHub when the manifest fails validation
   assert.equal(urls.length, 2);
 });
 
+test('fetchLatestRelease forwards cancellation and does not fall back after an abort', async () => {
+  const controller = new AbortController();
+  let calls = 0;
+  await assert.rejects(fetchLatestRelease({
+    cloudUrl: 'https://cloud.test',
+    signal: controller.signal,
+    fetchImpl: async (_url, options) => {
+      calls++;
+      assert.equal(options.signal.aborted, false);
+      controller.abort(new Error('cancelled'));
+      throw controller.signal.reason;
+    },
+  }), /cancelled/);
+  assert.equal(calls, 1, 'an aborted control-plane request must not trigger GitHub fallback');
+});
+
 // ---- latestReleaseCached
 
 test('latestReleaseCached fetches once, then serves the cache', () => withTempDir(async dir => {
@@ -147,6 +174,15 @@ test('detectInstallMethod distinguishes clones from packed installs', () => with
   assert.equal(detectInstallMethod(dir), 'clone');
 }));
 
+test('npmInstallSpec prefers an exact registry version and falls back when lookup fails', async () => {
+  const release = { version: '1.2.3', installSpec: 'github:B-icy/Carthagent#v1.2.3' };
+  let lookedUp;
+  assert.equal(await npmInstallSpec(release, async spec => { lookedUp = spec; return true; }), 'carthagent@1.2.3');
+  assert.equal(lookedUp, 'carthagent@1.2.3');
+  assert.equal(await npmInstallSpec(release, async () => false), release.installSpec);
+  assert.equal(await npmInstallSpec(release, async () => { throw new Error('npm unavailable'); }), release.installSpec);
+});
+
 // ---- staleGlobalInstallPaths / cleanStaleGlobalInstall
 
 test('staleGlobalInstallPaths flags non-directory carthagent and stash leftovers', () => withTempDir(dir => {

package/tests/verify-draft-runtime-gate.test.mjs

@@ -0,0 +1,280 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { execFileSync, spawnSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { REQUIRED_RELEASE_ASSETS, verifyDraftRuntimeGate } from '../tools/verify-draft-runtime-gate.mjs';
+
+const { version } = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
+const tag = `v${version}`;
+const sha = 'a'.repeat(40);
+const producerReleaseAssets = [
+  'opencode-linux-x64.tar.gz',
+  'opencode-linux-arm64.tar.gz',
+  'opencode-darwin-x64.tar.gz',
+  'opencode-darwin-arm64.tar.gz',
+  'opencode-windows-x64.tar.gz',
+  'runtime-release.json',
+  'runtime-release-SHA256SUMS.txt',
+].map((name) => ({ name }));
+const release = { id: 77, tag_name: tag, draft: true, assets: producerReleaseAssets };
+
+function mockRun({ releaseValue = release, remoteSha = sha, checkoutSha = sha, annotated = false } = {}) {
+  const calls = [];
+  const run = (command, args) => {
+    calls.push([command, args]);
+    if (command === 'git' && args[0] === 'rev-parse') return `${checkoutSha}\n`;
+    if (command !== 'gh') throw new Error(`Unexpected fake command ${command} ${args.join(' ')}`);
+    if (args[0] === 'api' && args[1] === `repos/B-icy/Carthagent/git/ref/tags/${tag}`) return JSON.stringify({ object: { type: annotated ? 'tag' : 'commit', sha: annotated ? 'c'.repeat(40) : remoteSha } });
+    if (args[0] === 'api' && args[1] === `repos/B-icy/Carthagent/git/tags/${'c'.repeat(40)}`) return JSON.stringify({ object: { type: 'commit', sha: remoteSha } });
+    if (args[0] === 'api' && args[1] === '--paginate' && args[2] === '--slurp' && args[3] === 'repos/B-icy/Carthagent/releases?per_page=100') return JSON.stringify([[releaseValue]]);
+    throw new Error(`Unexpected fake GitHub API call ${args.join(' ')}`);
+  };
+  return { run, calls };
+}
+
+test('accepts only the exact draft and returns its release ID and pinned commit', async () => {
+  const { run, calls } = mockRun();
+  const result = await verifyDraftRuntimeGate({ phase: 'before', releaseTag: tag, repo: 'B-icy/Carthagent', cwd: '/fixture', run });
+  assert.deepEqual(result, { releaseId: 77, sha, version });
+  assert.equal(calls.filter(([command]) => command === 'gh').length, 2);
+});
+
+test('resolves an annotated tag object to the exact commit before acceptance', async () => {
+  const { run, calls } = mockRun({ annotated: true });
+  const result = await verifyDraftRuntimeGate({ phase: 'before', releaseTag: tag, repo: 'B-icy/Carthagent', cwd: '/fixture', run });
+  assert.equal(result.sha, sha);
+  assert.equal(calls.some(([, args]) => args?.[1] === `repos/B-icy/Carthagent/git/tags/${'c'.repeat(40)}`), true);
+});
+
+test('rejects a malformed tag before invoking git or GitHub', async () => {
+  const { run, calls } = mockRun();
+  await assert.rejects(verifyDraftRuntimeGate({ phase: 'before', releaseTag: `not-${tag}`, repo: 'B-icy/Carthagent', run }), /must be exactly/);
+  assert.equal(calls.length, 0);
+});
+
+test('rejects a stale/moved tag before installed acceptance', async () => {
+  const { run, calls } = mockRun({ remoteSha: 'b'.repeat(40) });
+  await assert.rejects(verifyDraftRuntimeGate({ phase: 'before', releaseTag: tag, repo: 'B-icy/Carthagent', cwd: '/fixture', run }), /but this checkout is/);
+  assert.equal(calls.some(([command]) => command === 'git'), true);
+});
+
+test('rejects a published release before installed acceptance', async () => {
+  const { run, calls } = mockRun({ releaseValue: { ...release, draft: false } });
+  await assert.rejects(verifyDraftRuntimeGate({ phase: 'before', releaseTag: tag, repo: 'B-icy/Carthagent', run }), /must remain a draft/);
+  assert.equal(calls.some(([, args]) => args?.[1]?.includes('/git/ref/')), false);
+});
+
+test('requires the exact seven-asset producer contract: five archives, manifest, and combined checksums', async () => {
+  const expectedAssets = [
+    'opencode-linux-x64.tar.gz',
+    'opencode-linux-arm64.tar.gz',
+    'opencode-darwin-x64.tar.gz',
+    'opencode-darwin-arm64.tar.gz',
+    'opencode-windows-x64.tar.gz',
+    'runtime-release.json',
+    'runtime-release-SHA256SUMS.txt',
+  ];
+  assert.deepEqual(REQUIRED_RELEASE_ASSETS, expectedAssets);
+  const result = await verifyDraftRuntimeGate({
+    phase: 'before', releaseTag: tag, repo: 'B-icy/Carthagent', cwd: '/fixture',
+    run: mockRun({ releaseValue: { ...release, assets: expectedAssets.map((name) => ({ name })) } }).run,
+  });
+  assert.deepEqual(result, { releaseId: 77, sha, version });
+
+  for (const [label, assets, expected] of [
+    ['missing manifest', release.assets.filter(({ name }) => name !== 'runtime-release.json'), /exactly one runtime-release\.json asset/],
+    ['duplicate platform archive', [...release.assets, { name: REQUIRED_RELEASE_ASSETS[0] }], /exactly one opencode-linux-x64\.tar\.gz asset/],
+    ['unexpected extra asset', [...release.assets, { name: 'unreviewed-runtime.tar.gz' }], /unexpected assets: unreviewed-runtime\.tar\.gz/],
+    ['renamed checksum asset', release.assets.map((asset) => asset.name === 'runtime-release-SHA256SUMS.txt' ? { name: 'SHA256SUMS.txt' } : asset), /exactly one runtime-release-SHA256SUMS\.txt asset/],
+  ]) {
+    const { run } = mockRun({ releaseValue: { ...release, assets } });
+    await assert.rejects(verifyDraftRuntimeGate({ phase: 'before', releaseTag: tag, repo: 'B-icy/Carthagent', run }), expected, label);
+  }
+});
+
+test('the workflow precheck command fails before acceptance for malformed tag, moved tag, or published release', async (t) => {
+  const temp = await mkdtemp(path.join(tmpdir(), 'ctg-draft-gate-fake-gh-'));
+  t.after(() => rm(temp, { recursive: true, force: true }));
+  const requestsLog = path.join(temp, 'gh-requests');
+  const releaseFile = path.join(temp, 'release.json');
+  const targetFile = path.join(temp, 'target-sha');
+  const preloadFile = path.join(temp, 'fake-gh-preload.mjs');
+  const currentSha = spawnSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).stdout.trim();
+  await writeFile(targetFile, currentSha);
+  await writeFile(releaseFile, JSON.stringify(release));
+  await writeFile(preloadFile, `
+import fs from 'node:fs';
+import childProcess from 'node:child_process';
+import { syncBuiltinESMExports } from 'node:module';
+const originalSpawnSync = childProcess.spawnSync;
+childProcess.spawnSync = function(command, args, options) {
+  if (command !== 'gh') return originalSpawnSync.call(this, command, args, options);
+  fs.appendFileSync(process.env.FAKE_GH_LOG, JSON.stringify(args) + '\\n');
+  let stdout;
+  if (args.some(value => value.includes('/releases?per_page=100'))) {
+    stdout = JSON.stringify([[JSON.parse(fs.readFileSync(process.env.FAKE_RELEASE_JSON, 'utf8'))]]);
+  } else if (args.some(value => value.includes('/git/ref/tags/'))) {
+    stdout = JSON.stringify({ object: { type: 'commit', sha: fs.readFileSync(process.env.FAKE_TARGET_SHA, 'utf8').trim() } });
+  } else {
+    return { status: 2, stdout: '', stderr: 'Unexpected fake GitHub API call', error: undefined };
+  }
+  return { status: 0, stdout, stderr: '', error: undefined };
+};
+syncBuiltinESMExports();
+`);
+  const tool = fileURLToPath(new URL('../tools/verify-draft-runtime-gate.mjs', import.meta.url));
+  const invoke = (tagValue) => spawnSync(process.execPath, [tool, 'before', tagValue], {
+    cwd: path.resolve('.'), encoding: 'utf8',
+    env: {
+      ...process.env,
+      NODE_OPTIONS: `${process.env.NODE_OPTIONS ?? ''} --import=${pathToFileURL(preloadFile).href}`.trim(),
+      GITHUB_REPOSITORY: 'B-icy/Carthagent', GITHUB_OUTPUT: path.join(temp, 'github-output'),
+      FAKE_GH_LOG: requestsLog, FAKE_RELEASE_JSON: releaseFile, FAKE_TARGET_SHA: targetFile,
+    },
+  });
+
+  const malformed = invoke('not-a-version');
+  assert.notEqual(malformed.status, 0);
+  await assert.rejects(readFile(requestsLog));
+
+  await writeFile(targetFile, 'b'.repeat(40));
+  const stale = invoke(tag);
+  assert.notEqual(stale.status, 0);
+  assert.match(stale.stderr, /but this checkout is/);
+
+  await writeFile(targetFile, currentSha);
+  await writeFile(releaseFile, JSON.stringify({ ...release, draft: false }));
+  const published = invoke(tag);
+  assert.notEqual(published.status, 0);
+  assert.match(published.stderr, /must remain a draft/);
+});
+
+test('trusted inline bootstrap accepts a main tag and rejects non-main dispatch and a foreign tag', async (t) => {
+  const workflow = (await readFile(new URL('../.github/workflows/accept-draft-release.yml', import.meta.url), 'utf8')).replace(/\r\n/g, '\n');
+  const bootstrap = workflow.match(/- name: Require main dispatch and a release tag descended from origin\/main[\s\S]*?\n        run: \|\n((?:          .*\n)+)/)?.[1];
+  const postcheck = workflow.match(/- name: Reverify release tag ancestry against approved main after acceptance[\s\S]*?\n        run: \|\n((?:          .*\n?)+?)(?=\n      - |\n\s*$)/)?.[1];
+  assert.ok(bootstrap, 'trusted ancestry bootstrap block must be extractable');
+  assert.ok(postcheck, 'post-acceptance trusted ancestry block must be extractable');
+
+  const temp = await mkdtemp(path.join(tmpdir(), 'ctg-main-ancestry-'));
+  t.after(() => rm(temp, { recursive: true, force: true }));
+  const source = path.join(temp, 'source');
+  const bare = path.join(temp, 'origin.git');
+  const output = path.join(temp, 'github-output');
+  const fixtureVersion = '1.0.3';
+  const fixtureTag = `v${fixtureVersion}`;
+  await mkdir(source);
+  const git = (cwd, ...args) => execFileSync('git', args, { cwd, stdio: 'pipe' }).toString().trim();
+  git(source, 'init', '-b', 'main');
+  git(source, 'config', 'user.email', 'gate-fixture@example.invalid');
+  git(source, 'config', 'user.name', 'Gate Fixture');
+  await writeFile(path.join(source, 'package.json'), JSON.stringify({ version: fixtureVersion }));
+  git(source, 'add', 'package.json');
+  git(source, 'commit', '-m', 'approved main release commit');
+  const approvedSha = git(source, 'rev-parse', 'HEAD');
+  git(source, 'tag', '-a', fixtureTag, '-m', 'approved annotated draft release', approvedSha);
+  execFileSync('git', ['init', '--bare', bare], { stdio: 'pipe' });
+  git(source, 'remote', 'add', 'origin', bare);
+  git(source, 'push', 'origin', 'main', '--tags');
+
+  const bashPath = (value) => {
+    if (process.platform !== 'win32') return value;
+    return execFileSync('cygpath', ['-u', value], { encoding: 'utf8' }).trim();
+  };
+  const invoke = (script, ref, expectedSha = '') => spawnSync('bash', ['-euo', 'pipefail', '-c', script], {
+    cwd: source, encoding: 'utf8',
+    env: {
+      ...process.env,
+      GITHUB_REF: ref,
+      GITHUB_OUTPUT: bashPath(output),
+      RELEASE_TAG: fixtureTag,
+      TRUSTED_REPOSITORY_URL: bashPath(bare),
+      EXPECTED_SHA: expectedSha,
+    },
+  });
+
+  const accepted = invoke(bootstrap, 'refs/heads/main');
+  assert.equal(accepted.status, 0, accepted.stderr);
+  assert.match(await readFile(output, 'utf8'), new RegExp(`sha=${approvedSha}`));
+  assert.equal(invoke(bootstrap, 'refs/heads/release-candidate').status, 1);
+  assert.equal(invoke(postcheck, 'refs/heads/main', approvedSha).status, 0);
+
+  git(source, 'checkout', '-b', 'foreign/release');
+  await writeFile(path.join(source, 'foreign.txt'), 'not in main');
+  git(source, 'add', 'foreign.txt');
+  git(source, 'commit', '-m', 'unapproved foreign release commit');
+  git(source, 'tag', '-f', fixtureTag, 'HEAD');
+  git(source, 'push', 'origin', `+refs/tags/${fixtureTag}:refs/tags/${fixtureTag}`);
+  const rejectedForeign = invoke(bootstrap, 'refs/heads/main');
+  assert.equal(rejectedForeign.status, 1, rejectedForeign.stderr);
+  assert.match(rejectedForeign.stderr, /must point to a commit descended from approved origin\/main/);
+  const rejectedMovedTag = invoke(postcheck, 'refs/heads/main', approvedSha);
+  assert.equal(rejectedMovedTag.status, 1, rejectedMovedTag.stderr);
+  assert.match(rejectedMovedTag.stderr, /moved during acceptance/);
+});
+
+test('post-check requires the same release ID and the pre-acceptance tested SHA', async () => {
+  const { run: goodRun } = mockRun();
+  assert.deepEqual(await verifyDraftRuntimeGate({ phase: 'after', releaseTag: tag, expectedSha: sha, expectedReleaseId: 77, repo: 'B-icy/Carthagent', cwd: '/fixture', run: goodRun }), {
+    releaseId: 77, sha, version,
+  });
+  const { run: movedRun } = mockRun({ remoteSha: 'b'.repeat(40) });
+  await assert.rejects(verifyDraftRuntimeGate({ phase: 'after', releaseTag: tag, expectedSha: sha, expectedReleaseId: 77, repo: 'B-icy/Carthagent', cwd: '/fixture', run: movedRun }), /but this checkout is/);
+  const { run: idRun } = mockRun({ releaseValue: { ...release, id: 78 } });
+  await assert.rejects(verifyDraftRuntimeGate({ phase: 'after', releaseTag: tag, expectedSha: sha, expectedReleaseId: 77, repo: 'B-icy/Carthagent', run: idRun }), /identity changed/);
+});
+
+test('immediate pre-acceptance recheck pins the original SHA and release ID', async () => {
+  const { run } = mockRun();
+  assert.deepEqual(await verifyDraftRuntimeGate({ phase: 'recheck', releaseTag: tag, expectedSha: sha, expectedReleaseId: 77, repo: 'B-icy/Carthagent', cwd: '/fixture', run }), {
+    releaseId: 77, sha, version,
+  });
+  await assert.rejects(verifyDraftRuntimeGate({ phase: 'recheck', releaseTag: tag, expectedSha: 'b'.repeat(40), expectedReleaseId: 77, repo: 'B-icy/Carthagent', cwd: '/fixture', run }), /changed during acceptance/);
+  await assert.rejects(verifyDraftRuntimeGate({ phase: 'recheck', releaseTag: tag, expectedSha: sha, expectedReleaseId: 76, repo: 'B-icy/Carthagent', cwd: '/fixture', run }), /identity changed/);
+});
+
+test('draft workflow grants required push capability but performs only read operations', async () => {
+  const workflow = await readFile(new URL('../.github/workflows/accept-draft-release.yml', import.meta.url), 'utf8');
+  assert.match(workflow, /permissions:\s*\n\s+contents:\s+read/);
+  assert.match(workflow, /jobs:[\s\S]*?permissions:\s*\n\s+contents:\s+write/);
+  assert.match(workflow, /draft releases only to callers with push access/i);
+  assert.match(workflow, /minimum GITHUB_TOKEN capability/i);
+  assert.match(workflow, /token only for GETs/i);
+  const acceptance = workflow.match(/- name: Run the current full non-focused installed-package gate through the default resolver([\s\S]*?\n\s+run: npm run test:native-package)/)?.[0];
+  assert.ok(acceptance);
+  assert.match(acceptance, /CTG_REQUIRE_OWNED_RUNTIME:\s*['"]?1/);
+  assert.match(acceptance, /CTG_RUNTIME_GITHUB_TOKEN:\s*\$\{\{ github\.token \}\}/);
+  assert.match(acceptance, /GH_TOKEN:\s*['"]{2}/);
+  assert.match(workflow, /run: npm run test:native-package/);
+  assert.doesNotMatch(workflow, /gh release (?:create|upload|edit)|releases\/assets|curl .*cli\/releases/);
+  assert.doesNotMatch(workflow, /gh api\s+(?:--[^\n]*\s+)?--method\s+(?:POST|PATCH|PUT|DELETE)|gh api\s+-X\s+(?:POST|PATCH|PUT|DELETE)/i);
+  assert.match(workflow, /npm ci/);
+  assert.match(workflow, /npm run quality/);
+  assert.match(workflow, /verify-draft-runtime-gate\.mjs before/);
+  assert.match(workflow, /verify-draft-runtime-gate\.mjs recheck/);
+  assert.match(workflow, /verify-draft-runtime-gate\.mjs after/);
+  assert.match(workflow, /verify release tag ancestry against approved main after acceptance/);
+  const bootstrapIndex = workflow.indexOf('Require main dispatch and a release tag descended from origin/main');
+  const checkoutIndex = workflow.indexOf('uses: actions/checkout@v4');
+  const verifierIndex = workflow.indexOf('verify-draft-runtime-gate.mjs before');
+  assert.ok(bootstrapIndex >= 0 && bootstrapIndex < checkoutIndex && checkoutIndex < verifierIndex,
+    'trusted inline ancestry bootstrap must run before release checkout and tag-sourced verifier');
+  assert.match(workflow, /ref:\s*\$\{\{ steps\.trusted-ancestry\.outputs\.sha \}\}/,
+    'checkout must use the trusted ancestry-checked SHA, not resolve the mutable tag again');
+  const docs = (await readFile(new URL('../docs/opencode-owned-runtime.md', import.meta.url), 'utf8')).replace(/\r\n/g, '\n');
+  assert.match(docs, /current full,\s+non-focused installed-package gate/);
+  assert.match(docs, /exactly those seven assets/);
+  assert.match(docs, /independently reviewed host-controls, glyph,\s+controlled-terminal semantics, and visual-clear\/reopen probes are now composed\s+into that gate/);
+  assert.match(docs, /Their live final-artifact results remain pending/);
+});
+
+test('published release workflow explicitly empties optional draft credentials for public acceptance', async () => {
+  const workflow = await readFile(new URL('../.github/workflows/release.yml', import.meta.url), 'utf8');
+  const acceptance = workflow.match(/- name: Accept the installed package with its owned runtime required([\s\S]*?)(?=\n      - |\n\s+run:)/)?.[1];
+  const verify = workflow.match(/- name: Verify runtime archives against the packaged immutable manifest([\s\S]*?)(?=\n      - |\n\s+run:)/)?.[1];
+  assert.match(acceptance ?? '', /CTG_RUNTIME_GITHUB_TOKEN:\s*['"]{2}/);
+  assert.match(verify ?? '', /CTG_RUNTIME_GITHUB_TOKEN:\s*['"]{2}/);
+});