carthagent 1.0.7 → 1.1.0-beta.2

package/lib/opencode/update.mjs

@@ -0,0 +1,222 @@
+/** Shared native update operation for CLI and interactive callers. */
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { compareVersions, cleanStaleGlobalInstall, detectInstallMethod as detectDefaultInstallMethod, fetchLatestRelease, npmInstallSpec, packageVersion } from '../update.mjs';
+import { parseUpdateOptions, readUpdateChannel, writeUpdateChannel, releaseAllowedOnChannel } from '../update-channel.mjs';
+import { withoutRuntimeGithubToken } from '../environment.mjs';
+
+const SEMVER_TAG = /^v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const MAX_OUTPUT = 64 * 1024;
+
+/** Run a bounded child process and retain only a bounded combined output tail. */
+export function runUpdateCommand(argv, { cwd, timeoutSeconds = 600, env = process.env, signal, spawnImpl = spawn, platform = process.platform } = {}) {
+  return new Promise(resolve => {
+    let output = '';
+    let timedOut = false;
+    let settled = false;
+    if (signal?.aborted) { resolve({ code: 1, output: String(signal.reason ?? 'aborted'), timedOut: false, cancelled: true }); return; }
+    const child = spawnImpl(argv[0], argv.slice(1), { cwd, env: withoutRuntimeGithubToken(env), windowsHide: true, detached: platform !== 'win32', stdio: ['ignore', 'pipe', 'pipe'] });
+    const append = chunk => {
+      output = (output + chunk.toString()).slice(-MAX_OUTPUT);
+    };
+    child.stdout.on('data', append);
+    child.stderr.on('data', append);
+    let hardStop;
+    let killTimer;
+    let cancelled = false;
+    const stop = (force = false) => {
+      try {
+        if (platform !== 'win32' && child.pid) process.kill(-child.pid, force ? 'SIGKILL' : 'SIGTERM');
+        else {
+          if (platform === 'win32' && child.pid) {
+            const killer = spawnImpl('taskkill', ['/pid', String(child.pid), '/t', ...(force ? ['/f'] : [])], {
+              windowsHide: true,
+              env: withoutRuntimeGithubToken(env),
+              stdio: 'ignore',
+            });
+            killer.on('error', () => {});
+            killer.unref();
+          }
+          child.kill(force ? 'SIGKILL' : 'SIGTERM');
+        }
+      } catch { /* already exited */ }
+    };
+    const onAbort = () => {
+      cancelled = true;
+      stop();
+      killTimer = setTimeout(() => stop(true), 1500);
+      killTimer.unref?.();
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+    const timer = setTimeout(() => {
+      timedOut = true;
+      stop();
+      hardStop = setTimeout(() => stop(true), 5000);
+      hardStop.unref?.();
+    }, Math.max(1, timeoutSeconds) * 1000);
+    timer.unref?.();
+    const finish = code => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearTimeout(hardStop);
+      clearTimeout(killTimer);
+      signal?.removeEventListener('abort', onAbort);
+      resolve({ code: Number.isInteger(code) ? code : 1, output, timedOut, cancelled });
+    };
+    child.on('error', error => { append(error.message); finish(1); });
+    child.on('close', finish);
+  });
+}
+
+function npmArgv(args, platform = process.platform) {
+  // npm is a .cmd shim on Windows. Keep arguments as argv rather than a shell string.
+  return platform === 'win32' ? ['cmd.exe', '/d', '/s', '/c', 'npm', ...args] : ['npm', ...args];
+}
+
+function emit(io, level, message) {
+  const fn = io?.[level] || io?.log;
+  if (typeof fn === 'function') fn.call(io, message);
+}
+
+function commandSucceeded(result) {
+  return result?.code === 0 && result.timedOut !== true && result.cancelled !== true;
+}
+
+function commandFailure(label, result) {
+  const status = result?.timedOut ? ' (timed out)' : result?.cancelled ? ' (cancelled)' : '';
+  const detail = result?.output?.trim();
+  return new Error(`${label} failed${status}${detail ? `:\n${detail}` : ''}`);
+}
+
+function validatedRelease(release) {
+  if (!release || typeof release !== 'object') throw new Error('Latest release response is invalid.');
+  const version = String(release.version || '');
+  const tag = String(release.tag || '');
+  if (!SEMVER_TAG.test(tag) || !SEMVER_TAG.test(version) || tag.replace(/^v/, '') !== version.replace(/^v/, '')) {
+    throw new Error('Latest release has an invalid or mismatched version tag.');
+  }
+  const expectedSpec = `github:B-icy/Carthagent#${tag}`;
+  if (release.installSpec !== expectedSpec) throw new Error('Latest release install spec is not pinned to its validated release tag.');
+  return { ...release, version, tag, installSpec: expectedSpec };
+}
+
+/**
+ * Resolve and apply an update without terminating the host process.
+ *
+ * Returns `{status, release, method}` where status is `updated`, `current`,
+ * `ahead`, or `available` (`--check`). Failures throw after a bounded command
+ * reports a non-zero exit, allowing CLI/UI hosts to choose their own UX.
+ */
+export async function runNativeUpdate({
+  args = [], io = console, cwd = process.cwd(), root = cwd,
+  fetchLatestRelease: fetchRelease = fetchLatestRelease,
+  detectInstallMethod = detectDefaultInstallMethod,
+  runCommand = runUpdateCommand,
+  cleanStaleInstall = cleanStaleGlobalInstall,
+  currentVersion,
+  platform = process.platform,
+  nodeVersion = process.versions.node,
+  signal,
+  allowCloneUpdate = true,
+  env = process.env,
+} = {}) {
+  signal?.throwIfAborted();
+  const options = parseUpdateOptions(args);
+  const { checkOnly, force } = options;
+  const channel = options.channel ?? readUpdateChannel(env);
+  const remember = () => { if (options.channel !== null) writeUpdateChannel(channel, env); };
+  const resolved = await fetchRelease({ signal, channel, env });
+  signal?.throwIfAborted();
+  const release = validatedRelease(resolved?.release ?? resolved);
+  if (!releaseAllowedOnChannel(release, channel)) throw Error(`Release is not permitted on the ${channel} channel.`);
+  const installed = currentVersion || packageVersion();
+  if (!installed) throw new Error('Cannot determine the installed Carthagent version.');
+  const delta = compareVersions(installed, release.version);
+  if (release.minNode && compareVersions(nodeVersion, release.minNode) < 0) {
+    throw new Error(`Carthagent ${release.version} requires Node ≥ ${release.minNode} — this runtime is ${nodeVersion}`);
+  }
+  if (delta === 0 && !force) {
+    if (!checkOnly) remember();
+    emit(io, 'log', `Carthagent ${installed} is already the latest release.`);
+    return { status: 'current', release };
+  }
+  if (delta > 0 && !force && options.channel === null) {
+    emit(io, 'log', `Installed ${installed} is ahead of latest release ${release.version} — pass --force to reinstall anyway.`);
+    return { status: 'ahead', release };
+  }
+  if (checkOnly) {
+    emit(io, 'log', `Carthagent ${release.version} is available${release.note ? ` — ${release.note}` : ''} (installed: ${installed}) — run ctg update${options.channel === null ? '' : ` --channel ${channel}`}`);
+    return { status: 'available', release };
+  }
+
+  const method = detectInstallMethod(root);
+  signal?.throwIfAborted();
+  emit(io, 'log', `Updating Carthagent ${installed} → ${release.version} (${method} install)`);
+  const run = async (argv, label, timeoutSeconds = 600) => {
+    signal?.throwIfAborted();
+    const result = await runCommand(argv, { cwd: root, timeoutSeconds, ...(signal ? { signal } : {}) });
+    if (!commandSucceeded(result)) throw commandFailure(label, result);
+    return result;
+  };
+  const installGlobal = async (argv, label) => {
+    signal?.throwIfAborted();
+    let result = await runCommand(argv, { cwd: root, timeoutSeconds: 600, ...(signal ? { signal } : {}) });
+    if (!commandSucceeded(result) && !result?.timedOut && !result?.cancelled && /\bENOTDIR\b|\bEEXIST\b|\bENOTEMPTY\b/.test(result?.output || '')) {
+      const probe = await runCommand(npmArgv(['root', '-g'], platform), { cwd: root, timeoutSeconds: 30, ...(signal ? { signal } : {}) });
+      const removed = commandSucceeded(probe) ? cleanStaleInstall(probe.output.trim()) : [];
+      if (removed.length) {
+        emit(io, 'log', `Removed stale global install ${removed.length === 1 ? 'entry' : 'entries'} — retrying.`);
+        result = await runCommand(argv, { cwd: root, timeoutSeconds: 600, ...(signal ? { signal } : {}) });
+      }
+    }
+    if (!commandSucceeded(result)) throw commandFailure(label, result);
+  };
+
+  if (method === 'clone') {
+    if (!allowCloneUpdate) throw new Error('Native update refuses to checkout a release into the active source tree. Install Carthagent as an npm package or use `ctg update --check`.');
+    signal?.throwIfAborted();
+    const dirty = await runCommand(['git', 'status', '--porcelain'], { cwd: root, timeoutSeconds: 30, ...(signal ? { signal } : {}) });
+    if (!commandSucceeded(dirty)) throw new Error(`Cannot inspect the clone at ${root}${dirty?.output ? `: ${dirty.output.trim()}` : dirty?.timedOut ? ' (timed out)' : dirty?.cancelled ? ' (cancelled)' : ''}`);
+    if (dirty.output?.trim()) throw new Error(`The clone at ${root} has uncommitted changes. Commit, stash, or update it manually.`);
+    // Fetch this specific remote tag into a fresh private ref. This avoids
+    // trusting a pre-existing local tag and never overwrites user's local tags.
+    const fetchedRef = `refs/opencode-update/${randomUUID()}`;
+    let fetchAttempted = false;
+    try {
+      fetchAttempted = true;
+      await run(['git', 'fetch', '--no-tags', 'origin', `refs/tags/${release.tag}:${fetchedRef}`], `git fetch ${release.tag}`, 120);
+      const resolved = await run(['git', 'rev-parse', '--verify', `${fetchedRef}^{commit}`], `resolve fetched tag ${release.tag}`, 30);
+      const commit = resolved.output.trim();
+      if (!/^[0-9a-f]{40,64}$/i.test(commit)) throw new Error(`Could not resolve fetched release tag ${release.tag} to a commit.`);
+      await run(['git', 'checkout', '--detach', commit], `git checkout ${release.tag}`, 60);
+    } finally {
+      // Deleting our uniquely generated ref is best-effort and cannot touch
+      // any existing user tag or branch. Attempt it even when fetch reports
+      // cancellation: the remote write may have completed before termination.
+      if (fetchAttempted) {
+        try { await runCommand(['git', 'update-ref', '-d', fetchedRef], { cwd: root, timeoutSeconds: 30 }); }
+        catch { /* best-effort cleanup must not replace the original cancellation or update error */ }
+      }
+    }
+    await run(npmArgv(['ci'], platform), 'npm ci');
+    await installGlobal(npmArgv(['install', '-g', '.'], platform), 'npm install -g .');
+  } else if (method === 'npm') {
+    const installSpec = await npmInstallSpec(release, async registrySpec => {
+      const result = await runCommand(npmArgv(['view', registrySpec, 'version', '--json'], platform), {
+        cwd: root, timeoutSeconds: 10, ...(signal ? { signal } : {}),
+      });
+      signal?.throwIfAborted();
+      return commandSucceeded(result);
+    });
+    await installGlobal(npmArgv(['install', '-g', '--install-links=true', installSpec], platform), `npm install ${installSpec}`);
+  } else {
+    throw new Error(`Unsupported install method: ${method}`);
+  }
+  remember();
+  emit(io, 'log', `Carthagent updated to ${release.version}. Restart any running console to pick it up.`);
+  return { status: 'updated', release, method };
+}
+
+export { npmArgv as npmUpdateArgv };

package/lib/opencode/workspace.mjs

@@ -12,7 +12,7 @@ const activeOperations = new Set();
 
 /** @param {unknown} value @returns {TaskState} */
 function validState(value) {
-  if (!value || typeof value !== 'object' || !('version' in value) || value.version !== 1 || !('tasks' in value) || !Array.isArray(value.tasks) || !('operations' in value) || !Array.isArray(value.operations)) throw Error('Invalid CTG OpenCode workspace state');
+  if (!value || typeof value !== 'object' || !('version' in value) || value.version !== 1 || !('tasks' in value) || !Array.isArray(value.tasks) || !('operations' in value) || !Array.isArray(value.operations)) throw Error('Invalid CTG Carthagent runtime workspace state');
   return /** @type {TaskState} */ (value);
 }
 

package/lib/planning-advice.mjs

@@ -19,10 +19,10 @@ export async function inspectAdvice(state, capture, { enabled = false, createAdv
   if (prior) return { ...structuredClone(prior), captureId: capture.id, reused: true };
   if (attempts.length >= 3) return { mode: 'limit', authority: 'none', captureId: capture.id, instruction: 'Three advice attempts used; continue ordinary adversarial review.' };
   const attempt = { key, captureId: capture.id, runId: capture.runId, revision: capture.revision, digest: capture.digest, fingerprint: capture.fingerprint, at: new Date().toISOString(), mode: 'unavailable', authority: 'none', instruction: 'Attempt reserved; if interrupted, do not retry automatically. Ordinary review remains required.' };
-  attempts.push(attempt); persist(); // reserve durably before creating transport/dispatch
+  attempts.push(attempt); await persist(); // reserve durably before creating transport/dispatch
   let result;
   try { result = await advisePlan(capture.plan, { advisor: createAdvisor() }); }
   catch { result = { mode: 'unavailable', authority: 'none', findings: [], error: 'Jev configuration unavailable; ordinary review remains required.' }; }
   Object.assign(attempt, result, { instruction: 'Investigate only flagged topics (probability >= 0.5) and state dispositions in the normal review. Low scores are not flags, zero flags are not proof. Advice cannot approve or resolve blockers.' });
-  persist(); return structuredClone(attempt);
+  await persist(); return structuredClone(attempt);
 }

package/lib/providers/experiential.mjs

@@ -64,11 +64,11 @@ const EXPERIENTIAL_MODEL_PROFILES = Object.freeze({
   'glm-5.3-flash': { name: 'GLM 5.3 Flash', reasoning: true, thinkingLevelMap: TIERED_REASONING_LEVELS, contextWindow: 1_048_576, maxTokens: 32_768, input: ['text', 'image'], compat: { supportsReasoningEffort: true, thinkingFormat: 'zai' } },
   'glm-5.3': { name: 'GLM 5.3', reasoning: true, thinkingLevelMap: TIERED_REASONING_LEVELS, contextWindow: 1_048_576, maxTokens: 32_768, input: ['text'], compat: { supportsReasoningEffort: true, thinkingFormat: 'zai' } },
   'kimi-k3': { name: 'Kimi K3', reasoning: true, thinkingLevelMap: TIERED_REASONING_LEVELS, contextWindow: 1_048_576, maxTokens: 32_768, input: ['text'], compat: { supportsDeveloperRole: false, supportsReasoningEffort: true, thinkingFormat: 'deepseek' } },
-  'beam-1.0-501b-a23b': { name: 'Beam 1.0 501B A23B', reasoning: true, thinkingLevelMap: BEAM_REASONING_LEVELS, contextWindow: 1_048_576, maxTokens: 32_768, input: ['text'], compat: { supportsReasoningEffort: true } },
+  'beam-1.0-501b-a23b': { name: 'Beam 1.0 501B A23B', reasoning: true, thinkingLevelMap: BEAM_REASONING_LEVELS, contextWindow: 1_048_576, maxTokens: 32_768, input: ['text'], compat: { supportsReasoningEffort: true, reasoningField: 'reasoning_content', requireReasoning: true, reasoningPlaceholder: ' ' } },
   'mercury-3': { name: 'Mercury 3', reasoning: true, thinkingLevelMap: MERCURY3_REASONING_LEVELS, contextWindow: 1_048_576, maxTokens: 131_072, input: ['text'], compat: { supportsReasoningEffort: true } },
 });
 
-const MODEL_METADATA_FIELDS = ['reasoning', 'thinkingLevelMap', 'contextWindow', 'maxTokens', 'input', 'output', 'compat'];
+const MODEL_METADATA_FIELDS = ['reasoning', 'thinkingLevelMap', 'contextWindow', 'maxTokens', 'input', 'output', 'compat', 'cost'];
 
 export const EXPERIENTIAL_PROVIDER_ID = PROVIDER_ID;
 export const EXPERIENTIAL_PROVIDER_NAME = CARTHAGENT_SHIP_PROVIDER_NAME;

package/lib/providers/names.mjs

@@ -1,5 +1,5 @@
 export const CARTHAGENT_SHIP_PROVIDER_ID = 'experiential-labs';
-export const CARTHAGENT_SHIP_PROVIDER_NAME = 'Carthagent Ship';
+export const CARTHAGENT_SHIP_PROVIDER_NAME = 'Carthagent Cloud';
 
 export function providerDisplayName(providerId) {
   return providerId === CARTHAGENT_SHIP_PROVIDER_ID ? CARTHAGENT_SHIP_PROVIDER_NAME : String(providerId || '');

package/lib/tui/framing.mjs

@@ -1,80 +1 @@
-/**
- * Behind-the-scenes phased-delivery framing (the carthagent default flow).
- *
- * Every typed task is a phased delivery run: the raw text is what the user
- * sees echoed in the feed, while the engine receives the expanded delivery template
- * body. Resolving the template here (rather than forwarding "/guide <task>"
- * to the engine) keeps the behavior identical in --isolate and headless -p modes,
- * and keeps the machinery invisible in the feed.
- *
- * This is the default flow for carthagent — the whole product is built around it —
- * so the input pill stays empty and the hint rotates through generic
- * builder one-liners.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const ROOT = resolve(__dirname, '..', '..');
-const TEMPLATE_PATH = join(ROOT, 'prompts', 'delivery.md');
-
-let cached = null;
-
-export const FRAME_HINTS = ['Message carthagent…'];
-
-export function frameHint() {
-  return FRAME_HINTS[0];
-}
-
-function readTemplate(path) {
-  let body = '';
-  try {
-    const raw = readFileSync(path, 'utf8');
-    const fm = raw.match(/^---\n[\s\S]*?\n---\n?/);
-    body = (fm ? raw.slice(fm[0].length) : raw).trim();
-  } catch { body = ''; }
-  return body;
-}
-
-/** Body of prompts/delivery.md with frontmatter stripped. '' when unreadable. */
-export function framingTemplate(path = TEMPLATE_PATH) {
-  if (path === TEMPLATE_PATH) {
-    if (cached == null) cached = readTemplate(TEMPLATE_PATH);
-    return cached;
-  }
-  return readTemplate(path);
-}
-
-/** Expand the delivery template for a task. Falls back to the bare task text. */
-export function framePrompt(task, template = framingTemplate()) {
-  const t = String(task).trim();
-  if (!template) return t;
-  return template.includes('$@') ? template.replaceAll('$@', t) : `${template}\n\n${t}`;
-}
-
-/** Recover the original task text from a framed prompt, else null. */
-export function unframe(text) {
-  // Match the current template suffix first: the task itself may contain
-  // blank lines (or even phase headings). Keep the legacy format fallback.
-  const value = String(text);
-  const template = framingTemplate();
-  const parts = template.split('$@');
-  if (parts.length === 2 && value.startsWith(parts[0]) && value.endsWith(parts[1])) {
-    return value.slice(parts[0].length, parts[1] ? -parts[1].length : undefined).trim();
-  }
-  const m = value.match(/^Deliver this task in phases(?: with executable evidence)?:\s*([\s\S]*?)\n\n/);
-  return m ? m[1].trim() : null;
-}
-
-/** True when a submitted prompt should get the delivery framing. */
-export function shouldFrame(text, { enabled = true, delivery = true } = {}) {
-  if (!enabled || !delivery) return false;
-  const v = String(text).trim();
-  if (!v) return false;
-  if (v.startsWith('/') || v.startsWith('!')) return false;
-  // Questions/read-only asks are not delivery runs.
-  if (v.endsWith('?') && v.length < 300) return false;
-  if (/^(what|why|how|explain|show|list|describe|review|where|is|are|does|do|can)\b/i.test(v) && v.length < 300 && !/\b(build|create|implement|write|add|fix|make|generate)\b/i.test(v)) return false;
-  return existsSync(TEMPLATE_PATH);
-}
+export { FRAME_HINTS, frameHint, framingTemplate, framePrompt, unframe, shouldFrame } from '../../plugins/carthagent/src/server/framing.mjs';

package/lib/tui/models.mjs

@@ -30,7 +30,7 @@ export function providerForModel(model, list) {
 export function modelMatchesQuery(model, query) {
   const tokens = String(query || '').toLowerCase().match(/[\p{L}\p{N}]+/gu) || [];
   if (!tokens.length) return true;
-  const searchable = [model?.provider, providerDisplayName(model?.provider), model?.id, model?.full, model?.name]
+  const searchable = [model?.provider, providerDisplayName(model?.provider), model?.provider === 'experiential-labs' ? 'Carthagent Ship' : '', model?.id, model?.full, model?.name]
     .filter(Boolean)
     .join(' ')
     .toLowerCase();

package/lib/update.mjs

@@ -10,7 +10,7 @@
  * Install methods:
  *   - clone  : the package root contains .git (installed via `npm install -g .` from a
  *              clone) → checkout the tag in place, `npm ci`, re-link.
- *   - npm    : global `github:` install → `npm install -g --install-links=true <spec>`.
+ *   - npm    : global package install, preferring the exact npm registry version.
  */
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
@@ -151,6 +151,15 @@ export function detectInstallMethod(root) {
   return existsSync(join(root, '.git')) ? 'clone' : 'npm';
 }
 
+/** Prefer an exact registry release when available; retain the validated GitHub fallback. */
+export async function npmInstallSpec(release, npmView) {
+  const registrySpec = `carthagent@${release.version}`;
+  try {
+    if (await npmView(registrySpec)) return registrySpec;
+  } catch { /* registry unavailable or version not published */ }
+  return release.installSpec;
+}
+
 /**
  * Entries under a global node_modules dir that break `npm install -g` with
  * ENOTDIR/EEXIST: a non-directory `carthagent` entry (stray file or dangling

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "carthagent",
-  "version": "1.0.7",
+  "version": "1.1.0-beta.2",
   "workspaces": [
     "plugins/carthagent"
   ],
@@ -16,17 +16,18 @@
     "evidence-driven-delivery"
   ],
   "bin": {
-    "ctg": "./bin/ctg.mjs"
+    "ctg": "bin/ctg.mjs"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/B-icy/Carthagent"
+    "url": "git+https://github.com/B-icy/Carthagent.git"
   },
   "homepage": "https://github.com/B-icy/Carthagent#readme",
   "bugs": "https://github.com/B-icy/Carthagent/issues",
   "files": [
     "bin",
     "docs",
+    "script/ctg/build-owned-runtime.sh",
     "extensions",
     "guidance",
     "lib",
@@ -43,6 +44,7 @@
     "tests/*.mjs",
     "tests/*.py",
     "tests/fixtures/archive-plugin",
+    "tests/fixtures/native-discovery-plugin/server.ts",
     "tools",
     "vendor",
     "evaluate.mjs",
@@ -60,29 +62,53 @@
     "lint": "eslint . && npm run typecheck",
     "quality": "npm run lint && npm run build && npm test",
     "test:browser": "node tools/test-webdriver.mjs",
-    "test:native-host": "node tools/test-native-host.mjs",
+    "test:native-host": "node tools/test-native-host.mjs && node tools/test-native-ship-models.mjs",
+    "test:native-ship-models": "node tools/test-native-ship-models.mjs",
+    "test:native-product": "node tools/test-native-product.mjs",
+    "test:native-tasks": "node tools/test-native-tasks.mjs",
+    "test:native-review": "node tools/test-native-review.mjs",
+    "test:native-report": "node tools/test-native-report.mjs",
+    "test:native-runtime": "node tools/test-native-runtime.mjs",
+    "test:native-navigation": "cd plugins/carthagent && bun test --preload @opentui/solid/preload --timeout 30000 tests/voyages-navigation.test.tsx",
+    "test:native-performance": "node tools/test-native-performance.mjs",
+    "test:native-terminal-performance": "python3 tools/test-native-terminal-performance.py",
     "test:native-package": "node tools/test-native-package.mjs",
     "test:native-controls": "node tools/test-native-controls.mjs",
+    "test:native-ship-walkthrough": "node tools/test-native-ship-walkthrough.mjs",
+    "test:native-default-cli": "node tools/test-native-default-cli.mjs",
+    "test:owned-host-controls": "node tools/test-owned-host-controls.mjs",
+    "test:owned-visual-clear-env": "python3 tools/test-owned-visual-clear-env.py",
+    "test:native-terminal-semantics": "python3 tools/native-terminal-semantics.py",
+    "test:native-glyph-pty": "node tools/test-native-glyph-pty.mjs",
     "test:native-outcomes": "node tools/test-native-outcomes.mjs",
     "test:native-pty": "node tools/test-native-pty.mjs",
+    "test:owned-opencode": "node tools/test-owned-opencode-runtime.mjs",
     "build": "npm run check && npm run typecheck",
     "test": "node --test tests/*.test.mjs",
-    "test:python": "node tools/test-python.mjs"
+    "test:python": "node tools/test-python.mjs",
+    "test:native-slash-commands": "node tools/test-native-slash-commands.mjs",
+    "manual:prepare": "node tools/prepare-native-manual.mjs",
+    "manual:run": "node tools/native-manual.mjs"
   },
   "dependencies": {
-    "@opencode/cli": "2.0.32",
     "@opencode/client": "2.0.32",
     "@opencode/plugin": "2.0.32",
+    "@opencode/theme": "2.0.32",
+    "@opentui/core": "0.5.17",
+    "@opentui/solid": "0.5.17",
     "express": "^5.2.1",
     "jiti": "^2.7.0",
     "jsdom": "^30.0.1",
+    "solid-js": "1.9.12",
     "tree-sitter-wasms": "^0.1.13",
-    "web-tree-sitter": "^0.22.6"
+    "web-tree-sitter": "0.25.10",
+    "web-tree-sitter-legacy": "npm:web-tree-sitter@0.22.6"
   },
   "overrides": {
     "seroval": "1.6.9"
   },
   "devDependencies": {
+    "@opencode/cli": "2.0.32",
     "@eslint/js": "^10.0.1",
     "@types/node": "^24.3.0",
     "eslint": "^10.11.0",

package/plugins/carthagent/README.md

@@ -0,0 +1,23 @@
+# Carthagent OpenCode TUI plugin
+
+This is the V2.0.32-native Carthagent TUI host integration. OpenCode owns the terminal renderer, input editor, session lifecycle, model selectors, dialogs, route navigation, and command palette; this package adds Carthagent commands, workspace presentation, status contributions, and a matching semantic theme.
+
+## Commands
+
+The slash/palette inventory lives in `src/ui/commands.ts`. The plugin registers `/help` and `/ctg-help` to show Carthagent commands; the latter is the unambiguous alias if a host context claims `/help`. Both are covered by the pinned OpenCode 2.0.32 PTY smoke test. `/themes` and `/settings` remain native. The plugin leaves `/new` host-owned. CTG uses `/ctg-*` only for CTG-specific operations. `/model`, `/compact`, and `/abort` preserve their historical command names while providing provider-aware selection, notes-aware compaction and interruption. `/guide` toggles per-session framing when bare and sends the canonical delivery-framed task when given an argument. `/raw` tags that prompt with `ctg.raw` so the server bypasses framing without changing execution policy. Bare `/review` invokes the workspace server's independent reviewer, never the active session; `/review ask|yes|no` configures the automatic-review default in the Carthagent profile only, and does not disable the bare command. `/workflow`, `/architecture`, and `/evidence` render the selected session's authoritative workflow graph, architecture nodes/edges/ports, and bounded plan/evidence receipts, refreshing on native session/attention and server reconnect events. `/restart` interrupts only the selected session.
+
+`/copy` uses the native renderer's OSC 52 clipboard operation when supported. Unsupported terminals get a clear error and the response remains selectable. `/export [file]` writes a standalone HTML transcript into the active project directory and refuses to overwrite an existing file.
+
+## Workspace RPC
+
+The client imports the shared contracts from `../workspace-rpc.js` and `../session-rpc.js`; it does not duplicate RPC definitions. Each RPC call supplies the selected OpenCode location and a bounded abort timeout. Workspace event subscriptions are scoped to component lifetime, and events only invalidate data: the page refetches a complete snapshot after an event and on `server.connected`. Native session data is merged with the CTG snapshot only for sessions associated with the snapshot's projects; unrelated OpenCode sessions are not presented as CTG sessions. Workspace navigation actions are also available through `/ctg-open`, `/ctg-task`, and `/ctg-worktree` for keyboard-first use.
+
+## Host compatibility
+
+`/theme [name]` provisions the selected compatibility theme as OpenCode-native semantic theme JSON in the active native profile's `themes/` directory, then writes the selection to `cli.json` while preserving unrelated settings. Since OpenCode discovers theme files at startup, a newly installed theme requires one restart; selecting an already installed theme only changes `cli.json` and uses the host's live config reload. Launchers can call the standalone `provisionDefaultNativeTheme(configDirectory)` export from `src/ui/theme-provision.mjs` before starting OpenCode so `carthage` is available on the first launch. Provisioning does not overwrite an existing user-owned theme file. `/clear` clears only the visible transcript view using the host presentation API; durable session history is unchanged. `/autocompact [on|off]` persists an explicit, idempotent per-session setting; bare `/autocompact` toggles it.
+
+`/compact [notes]` uses the shared `carthagent.session.compact` RPC. The server stores notes for the compaction hook and reports whether the request was admitted; the native `session.compact` API itself does not accept `customInstructions`.
+
+## Theme
+
+`themes/carthage.json` uses the complete OpenCode V2 semantic hue/token structure and the approved Carthagent purple/gold identity. Remaining legacy palette names are converted to native OpenCode semantic tokens and hue scales by `src/ui/theme-provision.mjs` when provisioned. The default launcher provisioner is a separate export so the parent can invoke it without loading or editing the runtime entrypoint.

package/plugins/carthagent/src/bootstrap.ts

@@ -21,7 +21,7 @@ export default Plugin.define({
             const health = result as { hostVersion: string; directory: string };
             context.ui.toast.show({
               title: 'Carthagent',
-              message: `OpenCode ${health.hostVersion} · ${context.ui.format.path(health.directory)}`,
+              message: `Carthagent ${health.hostVersion} · ${context.ui.format.path(health.directory)}`,
               variant: 'success',
             });
           } catch (error) {

package/plugins/carthagent/src/daily-evidence.mjs

@@ -0,0 +1,57 @@
+// Pure, browser/native-safe counterpart of the backend's selected-evidence
+// policy. This validates shape/bytes, not truth, secrets, or assessment quality.
+const invalid = () => new Error('invalid_daily_evidence');
+const bytes = value => new TextEncoder().encode(value).byteLength;
+const uuid = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i;
+const hex = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i;
+function exact(value, keys) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+    || Reflect.ownKeys(value).length !== keys.length
+    || keys.some(key => {
+      const d = Object.getOwnPropertyDescriptor(value, key);
+      return !d?.enumerable || !Object.hasOwn(d, 'value');
+    })) throw invalid();
+}
+function text(value, limit) {
+  if (typeof value !== 'string' || bytes(value) > limit
+    || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\p{Cs}]/u.test(value)) throw invalid();
+  return value.replace(/\r\n?/g, '\n').trim();
+}
+function identifier(value, pattern) {
+  if (typeof value !== 'string' || !pattern.test(value)) throw invalid();
+  return value.toLowerCase();
+}
+function list(value, limit) {
+  if (!Array.isArray(value) || value.length > limit || Reflect.ownKeys(value).length !== value.length + 1) throw invalid();
+  for (let i = 0; i < value.length; i++) {
+    if (!Object.hasOwn(Object.getOwnPropertyDescriptor(value, String(i)) ?? {}, 'value')) throw invalid();
+  }
+  return value;
+}
+export function canonicalDailyEvidence(value) {
+  exact(value, ['projectId', 'outcomeId', 'runId', 'revision', 'goal', 'change', 'checks', 'findings']);
+  const revision = identifier(value.revision, hex);
+  const canonical = {
+    projectId: identifier(value.projectId, uuid), outcomeId: identifier(value.outcomeId, uuid), runId: identifier(value.runId, uuid), revision,
+    goal: text(value.goal, 1024), change: text(value.change, 3072),
+    checks: list(value.checks, 12).map(check => {
+      exact(check, ['name', 'before', 'after', 'revision', 'result']);
+      if (!['failed', 'not_run'].includes(check.before) || !['passed', 'failed', 'not_run'].includes(check.after)) throw invalid();
+      const checkedRevision = identifier(check.revision, hex);
+      if (check.after === 'passed' && checkedRevision !== revision) throw invalid();
+      return { name: text(check.name, 160), before: check.before, after: check.after, revision: checkedRevision, result: text(check.result, 1024) };
+    }),
+    findings: list(value.findings, 5).map(finding => {
+      exact(finding, ['issue', 'evidence', 'resolution']);
+      return { issue: text(finding.issue, 768), evidence: text(finding.evidence, 1536), resolution: text(finding.resolution, 1024) };
+    }),
+  };
+  if (bytes(JSON.stringify(canonical)) > 12288) throw invalid();
+  return canonical;
+}
+export function dailyRequest(id, evidence) {
+  const request = { id: identifier(id, uuid), consent: true, evidence: canonicalDailyEvidence(evidence) };
+  if (bytes(JSON.stringify(request)) > 16384) throw invalid();
+  return request;
+}

package/plugins/carthagent/src/daily-quests-rpc.ts

@@ -0,0 +1,50 @@
+import { Rpc } from '@opencode/plugin/rpc';
+
+export type DailyCheck = { name: string; before: 'failed' | 'not_run'; after: 'passed' | 'failed' | 'not_run'; revision: string; result: string };
+export type DailyFinding = { issue: string; evidence: string; resolution: string };
+export type DailyEvidence = { projectId: string; outcomeId: string; runId: string; revision: string; goal: string; change: string; checks: DailyCheck[]; findings: DailyFinding[] };
+export type DailySubmission = {
+  id: string; questId: string; status: 'queued' | 'grading' | 'graded' | 'failed'; decision: null | 'assessed_complete' | 'not_met' | 'needs_evidence';
+  scores: null | Record<string, number>; model: null | string; rubricVersion: null | string; attempts: number; createdAt: string; consentAt: string;
+  finishedAt: null | string; nextAttemptAt: null | string; errorCode: null | 'daily_grader_invalid' | 'daily_grader_unavailable' | 'daily_grader_timeout' | 'daily_grader_aborted' | 'daily_payload_expired' | 'daily_attempts_exhausted';
+  assessmentBasis: 'tui_submitted'; rewards: false;
+};
+export type DailyQuest = { id: string; day: string; definition: { templateId: string; title: string; kind: 'change' | 'tests' | 'review'; rubricVersion: string; criteria: { id: string; text: string }[] }; status: 'open' | 'assessed_complete'; endsAt: string; completedAt: string | null; assessmentBasis: 'tui_submitted'; rewards: false };
+export type DailyQuestDetail = DailyQuest & { latestSubmission: DailySubmission | null };
+export type DailySlate = { day: string; endsAt: string; policyVersion: string; items: DailyQuest[]; assessmentBasis: 'tui_submitted'; rewards: false };
+export type DailyRecord = { id: string; questId: string; createdAt: string; request: { id: string; consent: true; evidence: DailyEvidence } | null; submission: DailySubmission | null };
+export type DailySnapshot = { accountKey: string; slate: DailySlate; records: DailyRecord[] };
+
+// No arbitrary patterns: pinned native Effect conversion rejects them. Manual
+// validation enforces UUIDs, revisions, UTF-8 limits and cross-field bindings.
+const text = { type: 'string', maxLength: 4096 } as const;
+const id = { type: 'string', minLength: 36, maxLength: 36 } as const;
+const nullableText = { type: ['string', 'null'], maxLength: 4096 } as const;
+const yes = { type: 'boolean', const: true } as const;
+const basis = { assessmentBasis: { type: 'string', const: 'tui_submitted' }, rewards: { type: 'boolean', const: false } } as const;
+const object = <P extends Record<string, unknown>>(properties: P) => ({ type: 'object', properties, required: Object.keys(properties), additionalProperties: false } as const);
+const check = object({ name: text, before: { type: 'string', enum: ['failed', 'not_run'] }, after: { type: 'string', enum: ['passed', 'failed', 'not_run'] }, revision: text, result: text });
+const finding = object({ issue: text, evidence: text, resolution: text });
+const evidence = object({ projectId: id, outcomeId: id, runId: id, revision: text, goal: text, change: text, checks: { type: 'array', maxItems: 12, items: check }, findings: { type: 'array', maxItems: 5, items: finding } });
+const request = object({ id, consent: yes, evidence });
+const submission = object({
+  id, questId: id, status: { type: 'string', enum: ['queued', 'grading', 'graded', 'failed'] }, decision: { type: ['string', 'null'], enum: [null, 'assessed_complete', 'not_met', 'needs_evidence'] },
+  scores: { type: ['object', 'null'], additionalProperties: { type: 'number', minimum: 0, maximum: 1 } }, model: nullableText, rubricVersion: nullableText,
+  attempts: { type: 'integer', minimum: 0, maximum: 4 }, createdAt: text, consentAt: text, finishedAt: nullableText, nextAttemptAt: nullableText,
+  errorCode: { type: ['string', 'null'], enum: [null, 'daily_grader_invalid', 'daily_grader_unavailable', 'daily_grader_timeout', 'daily_grader_aborted', 'daily_payload_expired', 'daily_attempts_exhausted'] }, ...basis,
+});
+const questProperties = { id, day: text, definition: object({ templateId: text, title: text, kind: { type: 'string', enum: ['change', 'tests', 'review'] }, rubricVersion: text, criteria: { type: 'array', maxItems: 20, items: object({ id: text, text }) } }), status: { type: 'string', enum: ['open', 'assessed_complete'] }, endsAt: text, completedAt: nullableText, ...basis } as const;
+const quest = object(questProperties);
+const slate = object({ day: text, endsAt: text, policyVersion: text, items: { type: 'array', maxItems: 3, items: quest }, ...basis });
+const record = object({ id, questId: id, createdAt: text, request: { anyOf: [request, { type: 'null' }] }, submission: { anyOf: [submission, { type: 'null' }] } });
+const accountKey = { type: 'string', minLength: 64, maxLength: 64 } as const;
+const errors = { dailyQuestError: object({ code: text, status: { type: 'integer', minimum: 0, maximum: 599 }, uncertain: { type: 'boolean' } }) } as const;
+const result = object({ submission });
+export const DailyQuests = Rpc.define({ id: 'carthagent.dailyQuests', methods: {
+  snapshot: { errors, input: { type: 'object', additionalProperties: false }, output: object({ accountKey, slate, records: { type: 'array', maxItems: 64, items: record } }) },
+  detail: { errors, input: object({ id }), output: object({ ...questProperties, latestSubmission: { anyOf: [submission, { type: 'null' }] } }) },
+  submit: { errors, input: object({ accountKey, questId: id, id, consent: yes, evidence }), output: result },
+  retry: { errors, input: object({ accountKey, id }), output: result },
+  poll: { errors, input: object({ id }), output: result },
+  forgetPayload: { errors, input: object({ accountKey, id }), output: object({ ok: yes }) },
+}, events: {} });