carthagent 1.0.7 → 1.1.0-preview.13

package/docs/owned-host-controls-proof.md

@@ -0,0 +1,39 @@
+# CTG-owned host-controls behavioral proof
+
+`npm run test:owned-host-controls` is a focused Linux acceptance probe for the
+owned OpenCode runtime. It uses a disposable host profile/database and an
+offline loopback provider. Before invoking the product runtime resolver or
+starting the host, it verifies the selected staging artifact's executable bytes
+and embedded identity against `CTG_TEST_RUNTIME_RELEASE_MANIFEST`. The same
+`runtimeOptions` object (including the explicit staging root and trusted
+manifest path) is passed to both `resolveOpenCode()` and `runtimeIdentity()`.
+The printed identity comes from the verified artifact and is checked against
+the live server's `server.info()` response.
+
+The proof establishes session-specific `ctg.autoCompaction` metadata survives
+a service-process restart with the same database, then exercises actual
+overflow handling: disabled auto-compaction fails without a summary request;
+enabled auto-compaction sends a summary request and retries successfully. It
+also runs two concurrent shell tool calls with the same command, checks each
+session's successful durable tool result, and matches each provider tool-call ID
+to the hook's exact `{sessionID, origin, callID, command}` event. The fixture
+uses a Node-based shell command and is explicitly Linux-only; it makes no
+cross-platform shell or runtime-selection claim.
+
+This proof does **not** test clear behavior. In particular, it does not invoke
+`session.revert.clear`: that endpoint clears staged revert state and is unrelated
+to the TUI's visual `/clear` action. No claim about transcript presentation,
+visual clearing, or the `/clear` key/action is established here. Stored-message
+preservation under a visual clear remains unproven until that TUI behavior is
+launched and observed directly.
+
+An example invocation for a trusted local staging artifact is:
+
+```sh
+CTG_OWNED_OPENCODE_RUNTIME=/path/to/ctg-runtime \
+CTG_TEST_RUNTIME_RELEASE_MANIFEST=/path/to/trusted-runtime-release.json \
+npm run test:owned-host-controls
+```
+
+The explicit staging artifact is preflighted and reported as such. This is not
+evidence that the installed-package default resolver selected that artifact.

package/docs/owned-runtime-release-manifest.md

@@ -0,0 +1,42 @@
+# Generating the owned runtime release manifest
+
+`tools/generate-owned-runtime-release.mjs` converts the five native build outputs into a candidate `lib/opencode/runtime-release.json` trust root. It does not build binaries, publish artifacts, update a release, or commit the candidate.
+
+## Input directory contract
+
+The assets directory must contain exactly these ten regular files (no extra files or subdirectories):
+
+- `opencode-linux-x64.tar.gz` and `opencode-linux-x64.tar.gz.build.json`
+- `opencode-linux-arm64.tar.gz` and `opencode-linux-arm64.tar.gz.build.json`
+- `opencode-darwin-x64.tar.gz` and `opencode-darwin-x64.tar.gz.build.json`
+- `opencode-darwin-arm64.tar.gz` and `opencode-darwin-arm64.tar.gz.build.json`
+- `opencode-windows-x64.tar.gz` and `opencode-windows-x64.tar.gz.build.json`
+
+Each archive must be a USTAR gzip artifact in the layout consumed by `lib/opencode/runtime-artifact.mjs`. Inspection of the native build output shows the expected runtime tree includes the root `LICENSE`, `SHA256SUMS`, `ctg-runtime.json`, `cli-<target>/package.json`, and `cli-<target>/bin/opencode` (or `.exe` on Windows), plus only their parent directories. The generator accepts this complete build output, validates target package name/version/OS/CPU, and rejects unexpected files/directories inside the runtime archive. The source-recipe archives are not runtime archives and are not passed to this generator. The adjacent build record is JSON with this exact identity contract (additional fields are tolerated):
+
+```json
+{
+  "version": 1,
+  "target": "linux-x64",
+  "platform": "linux",
+  "arch": "x64",
+  "sourceRevision": "<40-character pinned source commit>",
+  "patchSha256": "<64-character digest>",
+  "lockSha256": "<64-character digest>",
+  "compatibilityVersion": "2.0.32",
+  "runtimeVersion": "0.0.0-ctg.2.0.32",
+  "executableSha256": "<64-character digest of the built executable>"
+}
+```
+
+The record is not trusted by itself. The generator takes the expected source, patch, lock, compatibility, and runtime identity from the reviewed prebuild recipe; verifies the patch bytes; computes each archive digest from the exact archive bytes; then supplies the record's executable digest and pinned provenance to the approved runtime acquisition API. That API parses the USTAR archive, checks embedded provenance, checks `SHA256SUMS`, and hashes the actual extracted executable. Any mismatch aborts generation.
+
+The generator emits the agreed outer schema with exactly five asset entries. It writes a new candidate file atomically and refuses to overwrite an existing candidate; review or remove a previous candidate explicitly before another generation. The supplied `releaseVersion` is the planned canonical semantic version; the final tagged-package gate must compare it with the final package's version.
+
+Example invocation after downloading the five archives and records from the native build jobs:
+
+```sh
+node tools/generate-owned-runtime-release.mjs 1.2.3 ./runtime-assets .
+```
+
+This writes `./runtime-release.json.candidate` next to `./runtime-assets`. The asset producer owns wiring the output into its own CI handoff. Do not check in dummy/sample digests as a production manifest.

package/docs/owned-visual-clear-proof.md

@@ -0,0 +1,40 @@
+# Owned TUI `/clear` behavioral proof
+
+`tools/test-owned-visual-clear.py` runs a disposable Linux/POSIX PTY against an
+explicitly selected, trusted-preflighted CTG-owned staging artifact and an
+offline loopback provider. It seeds two durable sessions, invokes the native
+TUI `/clear` command through slash autocomplete and Enter, and verifies the
+parsed terminal screen, durable conversational messages, continued prompting,
+an unaffected neighboring session, and restoration of session A's presentation
+cutoff after reopening it. A same-length, uncleared control session must show
+its old marker and follow-up marker together at the same PTY dimensions and
+initial viewport, ruling out ordinary scrolling as the explanation. The proof
+also reads the TUI's isolated `transcript-presentation.json` state and checks
+the exact cutoff message ID before and after reopening.
+
+The proof is intentionally narrow: it demonstrates visual transcript clearing
+for the tested owned staging artifact and no deletion of conversational
+messages. It does not test GUI/compositor presentation or the unrelated
+`session.revert.clear` endpoint. The PTY runner uses explicit child-environment
+allowlists, so it does not forward ambient credentials (including any case
+variant of `CTG_RUNTIME_GITHUB_TOKEN`) or read/print their values. Unit tests
+exercise rejection with fake values only. The runner uses the production
+`runtimeEnvironment()` profile builder for the isolated TUI, then restricts
+every spawned process to a small explicit environment allowlist. The fixture,
+preflight and API bridge receive only allowlisted path/locale inputs plus
+synthetic local fixture credentials; no ambient credential, profile, agent,
+or Node preload variables are inherited. Unit tests inject fake ambient
+credential names and assert they are not forwarded.
+
+Run with a trusted release manifest and selected runtime artifact:
+
+```sh
+python3 tools/test-owned-visual-clear.py \
+  --binary /path/to/owned-root/cli-linux-x64/bin/opencode \
+  --owned-root /path/to/owned-root \
+  --release-manifest /path/to/trusted/runtime-release.json
+```
+
+The helper verifies trusted release metadata, artifact provenance, exact
+runtime version, and executable digest before starting OpenCode. Compatibility
+and runtime versions are reported separately.

package/docs/patches/opencode-v2.0.32-glyph-spinner-test-isolation-v1.patch

@@ -0,0 +1,50 @@
+--- a/packages/tui/test/glyphs.test.ts
++++ b/packages/tui/test/glyphs.test.ts
+@@ -1,4 +1,5 @@
+ import { describe, expect, test } from "bun:test"
++import { fileURLToPath } from "node:url"
+ 
+ describe("host chrome glyph compatibility", () => {
+   test("maps known chrome symbols only in ASCII mode", async () => {
+@@ -36,9 +37,7 @@
+ 
+   test("selects ASCII spinner and border chrome without changing Unicode defaults", async () => {
+     process.env.CTG_TUI_GLYPHS = "ascii"
+-    const { SPINNER_FRAMES } = await import("../src/component/spinner-frames")
+     const { SplitBorder, EmptyBorder } = await import("../src/ui/border")
+-    expect(SPINNER_FRAMES).toEqual(["-", "\\", "|", "/"])
+     expect(SplitBorder.customBorderChars).toEqual({
+       topLeft: "+", bottomLeft: "+", vertical: "|", topRight: "+", bottomRight: "+",
+       horizontal: "-", bottomT: "+", topT: "+", cross: "+", leftT: "+", rightT: "+",
+@@ -47,6 +46,31 @@
+     process.env.CTG_TUI_GLYPHS = "unicode"
+     // Border characters are resolved at render time, so explicit Unicode remains intact.
+     expect(SplitBorder.customBorderChars).toEqual({ ...EmptyBorder, vertical: "┃" })
++
++    const entry = fileURLToPath(new URL("../src/component/spinner-frames.ts", import.meta.url))
++    for (const [mode, expected] of [
++      ["ascii", ["-", "\\", "|", "/"]],
++      ["unicode", ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]],
++    ] as const) {
++      const child = Bun.spawnSync(
++        [
++          process.execPath,
++          "-e",
++          [
++            'import assert from "node:assert/strict"',
++            `const { SPINNER_FRAMES } = await import(${JSON.stringify(entry)})`,
++            `assert.deepEqual(SPINNER_FRAMES, ${JSON.stringify(expected)})`,
++          ].join("\n"),
++        ],
++        {
++          cwd: fileURLToPath(new URL("..", import.meta.url)),
++          env: { ...process.env, CTG_TUI_GLYPHS: mode },
++          stdout: "pipe",
++          stderr: "pipe",
++        },
++      )
++      expect({ mode, exit: child.exitCode, stderr: child.stderr.toString() }).toEqual({ mode, exit: 0, stderr: "" })
++    }
+   })
+ 
+   test("keeps Unicode by default and supports explicit Unicode", async () => {