carthagent 0.0.0-stage → 1.0.7

package/tools/native-fixture.mjs

@@ -0,0 +1,194 @@
+/** Offline OpenAI-compatible SSE fixture used by the real OpenCode host test. */
+import { createServer } from 'node:http';
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { randomBytes } from 'node:crypto';
+import { OpenCode } from '@opencode/client';
+import { resolveOpenCode } from '../lib/opencode/runtime.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+
+export function createNativeFixture({ respond, inspect } = {}) {
+  let calls = 0;
+  const server = createServer(async (request, response) => {
+    let body = '';
+    for await (const chunk of request) body += chunk;
+    calls++;
+    const parsed = body ? JSON.parse(body) : {};
+    inspect?.({ request, body: parsed, call: calls });
+    if (!parsed.stream) {
+      response.writeHead(400, { 'content-type': 'application/json' });
+      response.end(JSON.stringify({ error: { message: 'stream=true required' } }));
+      return;
+    }
+    response.writeHead(200, { 'content-type': 'text/event-stream', connection: 'keep-alive' });
+    response.flushHeaders();
+    await respond?.({ request, body: parsed, call: calls, response });
+    response.end('data: [DONE]\n\n');
+  });
+  return {
+    server,
+    get calls() { return calls; },
+    listen: () => new Promise((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(0, '127.0.0.1', () => {
+        server.off('error', reject);
+        resolve(`http://127.0.0.1:${server.address().port}/v1`);
+      });
+    }),
+    close: () => new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve())),
+  };
+}
+
+export function toolCall(response, { id = 'fixture-call', name, arguments: input }) {
+  response.write(`data: ${JSON.stringify({
+    id: 'fixture-response', object: 'chat.completion.chunk', created: 1, model: 'fixture',
+    choices: [{ index: 0, delta: { role: 'assistant', tool_calls: [{
+      index: 0, id, type: 'function', function: { name, arguments: JSON.stringify(input) },
+    }] }, finish_reason: 'tool_calls' }],
+  })}\n\n`);
+}
+
+export function assistantText(response, text) {
+  response.write(`data: ${JSON.stringify({
+    id: 'fixture-response', object: 'chat.completion.chunk', created: 1, model: 'fixture',
+    choices: [{ index: 0, delta: { role: 'assistant', content: text }, finish_reason: 'stop' }],
+  })}\n\n`);
+}
+
+/** Disposable native OpenCode host and loopback provider for acceptance probes. */
+export async function nativeFixture({ plugin = join(root, 'plugins/carthagent'), plugins: additionalPlugins = [], extraPlugins = [], respond = (_body, res) => streamText(res), env: extraEnv = {} } = {}) {
+  const pluginPaths = [plugin, ...additionalPlugins, ...extraPlugins].filter(Boolean).map(path => resolve(path));
+  const temp = await mkdtemp(join(tmpdir(), 'ctg-native-fixture-'));
+  const cwd = join(temp, 'project');
+  const config = join(temp, 'config/opencode');
+  const requests = [];
+  const providerErrors = [];
+  let child;
+  let client;
+  let output = '';
+  const provider = createServer((req, res) => {
+    void (async () => {
+      let raw = '';
+      for await (const chunk of req) raw += chunk;
+      const body = JSON.parse(raw || '{}');
+      requests.push(body);
+      await respond(body, res, req);
+    })().catch(error => {
+      providerErrors.push(error);
+      if (!res.headersSent) res.writeHead(500);
+      res.end('Fixture provider failed');
+    });
+  });
+  const password = randomBytes(24).toString('hex');
+  const stop = async () => {
+    if (!child || child.exitCode !== null || child.signalCode !== null) return;
+    const exited = once(child, 'exit');
+    child.kill('SIGTERM');
+    const timer = setTimeout(() => child.kill('SIGKILL'), 5000);
+    try { await exited; } finally { clearTimeout(timer); }
+  };
+  const close = async () => {
+    await stop();
+    provider.closeAllConnections();
+    if (provider.listening) await new Promise(done => provider.close(done));
+    await rm(temp, { recursive: true, force: true });
+  };
+  const request = (milliseconds = 30_000) => ({ signal: AbortSignal.timeout(milliseconds) });
+  const start = async () => {
+    if (child && child.exitCode === null && child.signalCode === null) throw Error('Fixture host already running');
+    output = '';
+    const env = Object.fromEntries(['PATH', 'SystemRoot', 'WINDIR', 'COMSPEC', 'PATHEXT', 'LANG', 'LC_ALL']
+      .filter(key => process.env[key]).map(key => [key, process.env[key]]));
+    Object.assign(env, {
+      HOME: join(temp, 'home'), USERPROFILE: join(temp, 'home'), APPDATA: join(temp, 'appdata'), LOCALAPPDATA: join(temp, 'localappdata'),
+      XDG_CONFIG_HOME: join(temp, 'config'), XDG_DATA_HOME: join(temp, 'data'),
+      XDG_CACHE_HOME: join(temp, 'cache'), XDG_STATE_HOME: join(temp, 'state'),
+      OPENCODE_DB: join(temp, 'database.sqlite'), OPENCODE_SERVER_PASSWORD: password,
+      ...extraEnv,
+    });
+    child = spawn(await resolveOpenCode(),
+      ['serve', '--hostname', '127.0.0.1', '--port', '0', '--print-logs', '--log-level', 'debug'], { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    const baseUrl = await new Promise((done, reject) => {
+      const timer = setTimeout(() => reject(Error(`Host startup timeout: ${output}`)), 30_000);
+      const collect = chunk => {
+        output = (output + chunk).slice(-16384);
+        const url = output.match(/http:\/\/127\.0\.0\.1:\d+/)?.[0];
+        if (url) { clearTimeout(timer); done(url); }
+      };
+      child.stdout.on('data', collect);
+      child.stderr.on('data', collect);
+      child.once('error', error => { clearTimeout(timer); reject(error); });
+      child.once('exit', code => { clearTimeout(timer); reject(Error(`Host exited ${code}: ${output}`)); });
+    });
+    client = OpenCode.make({ baseUrl, headers: { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString('base64')}` } });
+    const version = (await client.server.info(request())).version;
+    if (version !== '2.0.32') throw Error(`Expected pinned host 2.0.32, got ${version}`);
+    return client;
+  };
+  try {
+    await Promise.all(['project', 'home', 'config/opencode', 'data', 'state', 'cache', 'appdata', 'localappdata']
+      .map(directory => mkdir(join(temp, directory), { recursive: true })));
+    provider.listen(0, '127.0.0.1');
+    await once(provider, 'listening');
+    await writeFile(join(config, 'opencode.json'), JSON.stringify({
+      ...(pluginPaths.length ? { plugins: pluginPaths } : {}), update: 'disable', model: 'ctg-fixture/fixture', default_agent: 'build',
+      providers: { 'ctg-fixture': {
+        package: '@opencode/ai/providers/openai-compatible',
+        settings: { baseURL: `http://127.0.0.1:${provider.address().port}/v1`, apiKey: 'offline-fixture' },
+        models: { fixture: { limit: { context: 32000, output: 1024 }, cost: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0 } } },
+      } },
+    }));
+    await start();
+  } catch (error) {
+    await close();
+    throw error;
+  }
+  return {
+    temp, cwd, requests, providerErrors, request, start, stop, close,
+    model: { providerID: 'ctg-fixture', id: 'fixture' },
+    location: { directory: cwd },
+    get client() { return client; },
+    get output() { return output; },
+    async outcome(sessionID) {
+      await client.session.wait({ sessionID }, request());
+      const deadline = Date.now() + 5000;
+      while (true) {
+        const session = await client.session.get({ sessionID }, request());
+        if (session.outcome) return session.outcome;
+        if (Date.now() >= deadline) throw Error(`Missing terminal outcome for ${sessionID}`);
+        await new Promise(done => setTimeout(done, 20));
+      }
+    },
+    async active(pluginID = 'carthagent', location = { directory: cwd }) {
+      if (pluginID && typeof pluginID === 'object') {
+        location = pluginID;
+        pluginID = 'carthagent';
+      }
+      await client.session.create({ location, model:{providerID:'ctg-fixture',id:'fixture'}, title:`${pluginID} activation probe` }, request());
+      const deadline = Date.now() + 15_000;
+      while (true) {
+        const inventory = await client.plugin.list({ location }, request());
+        const plugin = inventory.data.find(item => item.id === pluginID);
+        if (plugin?.state.status === 'active') return;
+        if (plugin?.state.status === 'failed') throw Error(`Native fixture plugin failed: ${JSON.stringify(plugin)}\n${output}`);
+        if (Date.now() >= deadline) throw Error(`Native plugin ${pluginID} activation timed out: ${JSON.stringify(plugin)}\n${output}`);
+        await new Promise(done => setTimeout(done, 50));
+      }
+    },
+  };
+}
+
+export function streamText(response, text = 'Fixture response complete.') {
+  response.writeHead(200, { 'content-type': 'text/event-stream' });
+  const chunk = (delta, finish_reason = null) => `data: ${JSON.stringify({
+    id: 'fixture', object: 'chat.completion.chunk', created: 1, model: 'fixture',
+    choices: [{ index: 0, delta, finish_reason }],
+    ...(finish_reason ? { usage: { prompt_tokens: 20, completion_tokens: 5, total_tokens: 25 } } : {}),
+  })}\n\n`;
+  response.write(chunk({ role: 'assistant', content: text }));
+  response.end(`${chunk({}, 'stop')}data: [DONE]\n\n`);
+}

package/tools/native-pty-smoke.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Exercise a native CTG plugin command in a disposable real terminal host."""
+import argparse
+import fcntl
+import json
+import os
+import pathlib
+import pty
+import re
+import select
+import shutil
+import signal
+import struct
+import subprocess
+import tempfile
+import termios
+import time
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--binary', default=shutil.which('opencode'))
+    parser.add_argument('--plugin', default=str(pathlib.Path(__file__).resolve().parents[1] / 'plugins/carthagent/test-plugin'))
+    parser.add_argument('--delivery-plugin', default=str(pathlib.Path(__file__).resolve().parents[1] / 'plugins/carthagent/test-plugin'))
+    parser.add_argument('--command', default='/ctg-status')
+    parser.add_argument('--expect', default=None)
+    parser.add_argument('--completion', default='Carthagent runtime status')
+    args = parser.parse_args()
+    if not args.binary:
+        parser.error('OpenCode binary is required')
+    args.binary = str(pathlib.Path(args.binary).resolve())
+    with tempfile.TemporaryDirectory(prefix='ctg-pty-') as temp:
+        root = pathlib.Path(temp)
+        for name in ['home', 'project', 'config/opencode', 'data', 'state', 'cache']:
+            (root / name).mkdir(parents=True, exist_ok=True)
+        (root / 'config/opencode/opencode.json').write_text(json.dumps({
+            'plugins': list(dict.fromkeys([str(pathlib.Path(args.plugin).resolve()), str(pathlib.Path(args.delivery_plugin).resolve())])), 'update': 'disable',
+        }))
+        expected = args.expect or 'OpenCode 2.0.32 ·'
+        env = {key: os.environ[key] for key in ['PATH', 'LANG', 'LC_ALL'] if key in os.environ}
+        env.update({
+            'HOME': str(root / 'home'), 'TERM': 'xterm-256color', 'COLORTERM': 'truecolor',
+            'XDG_CONFIG_HOME': str(root / 'config'), 'XDG_DATA_HOME': str(root / 'data'),
+            'XDG_STATE_HOME': str(root / 'state'), 'XDG_CACHE_HOME': str(root / 'cache'),
+            'OPENCODE_DB': str(root / 'database.sqlite'),
+        })
+        master, slave = pty.openpty()
+        fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack('HHHH', 36, 120, 0, 0))
+        child = subprocess.Popen([args.binary, '--standalone'], cwd=root / 'project', env=env,
+                                 stdin=slave, stdout=slave, stderr=slave, start_new_session=True)
+        os.close(slave)
+        output = bytearray()
+        started = time.monotonic()
+        sent = False
+        completion_accepted = False
+        submitted = False
+        try:
+            while time.monotonic() - started < 30:
+                if child.poll() is not None:
+                    raise RuntimeError(f'Native TUI exited early: {child.returncode}')
+                if select.select([master], [], [], 0.1)[0]:
+                    chunk = os.read(master, 65536)
+                    output.extend(chunk)
+                    # Terminal capability requests need replies on a headless PTY.
+                    if b'\x1b[6n' in chunk:
+                        os.write(master, b'\x1b[1;1R')
+                    if b'\x1b[c' in chunk:
+                        os.write(master, b'\x1b[?1;2c')
+                if not sent and time.monotonic() - started > 8:
+                    os.write(master, args.command.encode())
+                    sent = True
+                # The completion row is evidence that the TUI plugin has
+                # registered its command. Enter submits the highlighted slash
+                # command; inspect only output produced after that submission.
+                if sent and not completion_accepted and args.completion.encode() in output:
+                    completion_accepted = True
+                    os.write(master, b'\r')
+                    submitted = True
+                    output.clear()
+                plain_output = re.sub(rb'\x1b\[[0-?]*[ -/]*[@-~]', b'', bytes(output))
+                if submitted and expected.encode() in plain_output:
+                    if b'runtime unavailable' in plain_output or args.completion.encode() in plain_output:
+                        raise RuntimeError('Command was unavailable or its RPC failed')
+                    print(json.dumps({'command': args.command, 'observed': expected,
+                                      'completionAccepted': completion_accepted,
+                                      'commandSubmitted': submitted,
+                                      'elapsedMs': round((time.monotonic() - started) * 1000),
+                                      'terminalBytes': len(output)}))
+                    return
+            plain = re.sub(rb'\x1b\[[0-?]*[ -/]*[@-~]', b'', bytes(output))
+            for log in (root / 'data').rglob('*.log'):
+                lines = [line for line in log.read_text(errors='replace').splitlines()
+                         if 'plugin' in line.lower() or 'error' in line.lower()]
+                print('\n'.join(lines[-30:]))
+            raise RuntimeError(f'Expected post-command response {expected!r} not rendered (sent={sent}, completionAccepted={completion_accepted}, submitted={submitted}): {plain[-8000:].decode(errors="replace")}')
+        finally:
+            if child.poll() is None:
+                os.killpg(child.pid, signal.SIGTERM)
+                try:
+                    child.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    os.killpg(child.pid, signal.SIGKILL)
+                    child.wait()
+            os.close(master)
+
+
+if __name__ == '__main__':
+    main()

package/tools/native-report-plugin/index.ts

@@ -0,0 +1,50 @@
+import { Plugin } from '@opencode/plugin';
+import { registerWorkspaceRpc } from '../../plugins/carthagent/src/server/workspace-rpc';
+import { Rpc } from '@opencode/plugin/rpc';
+import { Workspace } from '../../plugins/carthagent/src/workspace-rpc';
+
+const SchemaProbe = Rpc.define({
+  id: 'carthagent.report-schema-probe',
+  methods: {
+    incompleteVerified: { input: { type: 'object', additionalProperties: false }, output: { oneOf: Workspace.methods.delivery.output.oneOf } },
+    invalidWithFullFields: { input: { type: 'object', additionalProperties: false }, output: Workspace.methods.delivery.output },
+    validUnavailable: { input: { type: 'object', additionalProperties: false }, output: { oneOf: Workspace.methods.delivery.output.oneOf } },
+    validInvalid: { input: { type: 'object', additionalProperties: false }, output: { oneOf: Workspace.methods.delivery.output.oneOf } },
+    validActive: { input: { type: 'object', additionalProperties: false }, output: { oneOf: Workspace.methods.delivery.output.oneOf } },
+  },
+  events: {},
+});
+
+export default Plugin.define({
+  id: 'carthagent-report-fixture',
+  async setup(context) {
+    const disposeWorkspace = await registerWorkspaceRpc(context);
+    try {
+      const probe = await context.rpc.register(SchemaProbe, {
+        incompleteVerified: async () => ({ status: 'verified' }),
+        invalidWithFullFields: async () => ({
+          status: 'invalid', freshness: 'current', completion: 'ready', gate: 'open',
+          runId: 'forged-run', revision: 1, fingerprint: 'a'.repeat(64),
+          plan: {}, workflow: {}, architecture: {}, evidence: [], truncation: {},
+        }),
+        validUnavailable: async () => ({ status: 'unavailable' }),
+        validInvalid: async () => ({ status: 'invalid' }),
+        validActive: async () => ({
+          status: 'active', freshness: 'current', completion: 'incomplete', gate: 'open',
+          runId: 'active-run', revision: 1, fingerprint: 'a'.repeat(64),
+          plan: { goal: 'Goal', verification: 'required', acceptance: [], artifacts: [], outputs: [], assumptions: [], checks: [], steps: [], scenarios: [], risks: [] },
+          workflow: { authored: false, semantics: '', nodes: [], edges: [] },
+          architecture: { nodes: [], edges: [], ports: [] }, evidence: [],
+          truncation: Object.fromEntries(['checks', 'acceptance', 'steps', 'artifacts', 'outputs', 'assumptions', 'scenarios', 'risks', 'workflowNodes', 'workflowEdges', 'architectureNodes', 'architectureEdges', 'architecturePorts'].map(key => [key, { returned: 0, total: 0 }])),
+        }),
+      });
+      return async () => {
+        try { await probe.dispose(); }
+        finally { await disposeWorkspace(); }
+      };
+    } catch (error) {
+      await disposeWorkspace();
+      throw error;
+    }
+  },
+});

package/tools/native-report-plugin/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "ctg-native-report-fixture",
+  "type": "module",
+  "exports": {
+    ".": "./index.ts"
+  }
+}

package/tools/patch-compaction.mjs

@@ -0,0 +1,24 @@
+// Reapply after refreshing the vendored engine. Fail closed if upstream changes.
+import { readFileSync, writeFileSync } from 'node:fs';
+const path = new URL('../vendor/agent/chunks/chunk-JVUZSMYM.js', import.meta.url);
+let source = readFileSync(path, 'utf8');
+if (source.includes('import{boundedSummary,compactionThreshold,serializedContextTokens}')) process.exit(0);
+function replaceOnce(from,to) {
+  if (source.split(from).length !== 2) throw new Error(`Expected one vendor anchor: ${from.slice(0,100)}`);
+  source = source.replace(from,to);
+}
+source = 'import{boundedSummary,compactionThreshold,serializedContextTokens}from"../bounded-summary.mjs";\n' + source;
+for (const name of ['shouldCompact','shouldCompact2']) replaceOnce(`function ${name}(contextTokens,contextWindow,settings2){return settings2.enabled&&Number.isFinite(contextWindow)&&contextWindow>0?contextTokens>contextWindow-settings2.reserveTokens:!1}`,`function ${name}(contextTokens,contextWindow,settings2){return settings2.enabled&&Number.isFinite(contextWindow)&&contextWindow>0?contextTokens>compactionThreshold(contextWindow,settings2.reserveTokens):!1}`);
+replaceOnce('return retryAssistantCall(async()=>streamFn?(await streamFn(model,context,requestOptions)).result():completeSimple(model,context,requestOptions),retry,requestOptions.signal,callbacks)', 'return boundedSummary(model,context,requestOptions,(boundedContext,boundedOptions)=>retryAssistantCall(async()=>streamFn?(await streamFn(model,boundedContext,boundedOptions)).result():completeSimple(model,boundedContext,boundedOptions),retry,boundedOptions.signal,callbacks))');
+const summaryCall = 'response=await request({systemPrompt:SUMMARIZATION_SYSTEM_PROMPT2,messages:summarizationMessages},createSummaryRequestOptions(completionOptions,context),context)';
+if (source.split(summaryCall).length !== 3) throw new Error('Expected history and turn-prefix summary calls');
+source = source.replaceAll(summaryCall, 'response=await boundedSummary(model,{systemPrompt:SUMMARIZATION_SYSTEM_PROMPT2,messages:summarizationMessages},createSummaryRequestOptions(completionOptions,context),(boundedContext,boundedOptions)=>request(boundedContext,boundedOptions,context))');
+// Include serialized UTF-8 size even when cached-token usage is available.
+for (const [from,to] of [
+  ['return{tokens:estimated,usageTokens:0,trailingTokens:estimated,lastUsageIndex:null}', 'return{tokens:Math.max(estimated,serializedContextTokens(messages)),usageTokens:0,trailingTokens:estimated,lastUsageIndex:null}'],
+  ['return{tokens:usageTokens+trailingTokens,usageTokens,trailingTokens,lastUsageIndex:usageInfo.index}', 'return{tokens:Math.max(usageTokens+trailingTokens,serializedContextTokens(messages)),usageTokens,trailingTokens,lastUsageIndex:usageInfo.index}'],
+]) {
+  if (source.split(from).length !== 3) throw new Error('Expected both context estimator paths');
+  source=source.replaceAll(from,to);
+}
+writeFileSync(path,source);

package/tools/patch-model-catalog.mjs

@@ -0,0 +1,12 @@
+// Reapply after refreshing the vendored engine; fail closed on changed anchors.
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const file = new URL('../vendor/agent/chunks/chunk-JVUZSMYM.js', import.meta.url);
+let source = readFileSync(file, 'utf8');
+const marker = '/* Carthagent owns model discovery; no pi.dev catalog. */';
+if (!source.includes(marker)) {
+  const anchor = 'function withRemoteCatalog(provider,catalogBaseUrl=DEFAULT_CATALOG_BASE_URL,localGeneratedAt){';
+  if (source.split(anchor).length !== 2) throw new Error('Vendored model catalog anchor changed');
+  source = source.replace(anchor, `${anchor}${marker}return provider;`);
+  writeFileSync(file, source);
+}

package/tools/patch-print-shutdown.mjs

@@ -0,0 +1,39 @@
+// Reapply after refreshing the vendored engine. Fail closed if upstream changes.
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const path = process.argv[2]
+  ? pathToFileURL(resolve(process.argv[2]))
+  : new URL('../vendor/agent/chunks/chunk-JVUZSMYM.js', import.meta.url);
+let source = readFileSync(path, 'utf8');
+const marker = 'undici.getGlobalDispatcher()===dispatcher&&await dispatcher.destroy(),await flushRawStdout()';
+
+if (source.includes(marker)) {
+  // Already patched; accept only the exact expected declaration/finalizer pair.
+  const declaration = 'signalCleanupHandlers=[],dispatcher=undici.getGlobalDispatcher(),disposeRuntime=async()=>';
+  if (source.split(marker).length !== 2 || source.split(declaration).length !== 2) {
+    throw new Error('Found print shutdown marker without its dispatcher ownership guard');
+  }
+} else {
+  const declaration = 'signalCleanupHandlers=[],disposeRuntime=async()=>';
+  const replacement = 'signalCleanupHandlers=[],dispatcher=undici.getGlobalDispatcher(),disposeRuntime=async()=>';
+  if (source.split(declaration).length !== 2) {
+    throw new Error('Expected exactly one print-mode runtime declaration anchor');
+  }
+  source = source.replace(declaration, replacement);
+
+  const finalizers = [
+    'await disposeRuntime(),await flushRawStdout()',
+    'await disposeRuntime(),await globalThis[Symbol.for("carthagent.httpDispatcher.close")]?.(),await flushRawStdout()',
+    'await disposeRuntime(),undici.getGlobalDispatcher()===dispatcher&&await dispatcher.destroy(),await flushRawStdout()',
+  ];
+  const finalizer = finalizers.find(anchor => source.split(anchor).length === 2);
+  const patchedFinalizer = 'await disposeRuntime(),undici.getGlobalDispatcher()===dispatcher&&await dispatcher.destroy(),await flushRawStdout()';
+  if (!finalizer) {
+    throw new Error('Expected exactly one print-mode finalizer anchor');
+  }
+  source = source.replace(finalizer, patchedFinalizer);
+}
+
+writeFileSync(path, source);

package/tools/repo-pilot/evaluator.cjs

@@ -0,0 +1,32 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const fastify = require(path.join(process.cwd(),'fastify.js'));
+const task = process.argv[2];const rows=[];
+async function category(name, fn){try{await fn();rows.push({name,passed:true});}catch(e){rows.push({name,passed:false,error:String(e.message).slice(0,1200)});}}
+async function scenario(fn, {real=false,hook=false}={}) {
+ const app=fastify();let failure;
+ app.register(async child=>{
+  if(hook)child.addHook('onSend',async(req,reply,payload)=>{try{fn(reply,req);}catch(e){failure=e;}return payload;});
+  child.get('/',(req,reply)=>{if(!hook)try{fn(reply,req);}catch(e){failure=e;}reply.send('ok');});
+ });
+ try{let result;if(real){await app.listen({port:0,host:'127.0.0.1'});const r=await fetch(app.listeningOrigin);result={statusCode:r.status,headers:Object.fromEntries(r.headers),cookies:r.headers.getSetCookie()};await r.text();}else result=await app.inject('/');if(failure)throw failure;assert.equal(result.statusCode,200);return result;}finally{await app.close();}
+}
+(async()=>{
+ if(task==='append'){
+ await category('chainable effective header and order',()=>scenario(r=>{assert.equal(r.appendHeader('X-Test','one'),r);r.appendHeader('x-test',[0,'','two,two']);assert.deepEqual(r.getHeader('X-TEST'),['one','0','','two,two']);}));
+ await category('raw precedence and no alias mutation',()=>scenario(r=>{const old=['a'];r.raw.setHeader('x-test',old);r.appendHeader('X-Test',['b']);assert.deepEqual(old,['a']);assert.deepEqual(r.getHeader('x-test'),['a','b']);r.header('x-test','override');r.appendHeader('x-test','c');assert.deepEqual(r.getHeader('x-test'),['override','c']);}));
+ await category('set-cookie append exactly once',async()=>{const v=await scenario(r=>{r.header('set-cookie',['a=1']);r.appendHeader('Set-Cookie',['b=2','c=3']);},{real:true});assert.deepEqual(v.cookies,['a=1','b=2','c=3']);});
+ await category('array copied empty no-op',()=>scenario(r=>{const values=['a'];r.appendHeader('x-test',values);values.push('b');assert.deepEqual(r.getHeader('x-test'),['a']);r.appendHeader('x-test',[]);assert.deepEqual(r.getHeader('x-test'),['a']);}));
+ await category('atomic invalid values and names',()=>scenario(r=>{r.header('x-test','old');for(const bad of [undefined,null,{},NaN,Infinity,['good','bad\r\nx'],['good',{}],['good','x\u0000']]){assert.throws(()=>r.appendHeader('x-test',bad),TypeError);assert.equal(r.getHeader('x-test'),'old');}for(const name of ['bad name','',':bad',7])assert.throws(()=>r.appendHeader(name,[]),TypeError);}));
+ await category('onSend real HTTP and normal header unaffected',async()=>{const v=await scenario(r=>{r.header('x-other','before');r.header('x-other','after');r.appendHeader('x-test','a').appendHeader('x-test','b');},{real:true,hook:true});assert.equal(v.headers['x-test'],'a, b');assert.equal(v.headers['x-other'],'after');});
+ } else {
+ await category('chainable token normalization',()=>scenario(r=>{assert.equal(r.vary('Accept-Encoding, Accept'),r);r.vary(['accept-encoding',' Origin , accept']);assert.equal(r.getHeader('vary'),'Accept-Encoding, Accept, Origin');}));
+ await category('raw header merge Fastify precedence',()=>scenario(r=>{r.raw.setHeader('Vary',['Accept','accept']);r.vary('Origin');assert.equal(r.getHeader('vary'),'Accept, Origin');r.header('vary','X-Custom');r.vary('Accept');assert.equal(r.getHeader('vary'),'X-Custom, Accept');}));
+ await category('wildcard dominance all input validated',()=>scenario(r=>{r.vary('Accept');r.vary(['Origin','*']);assert.equal(r.getHeader('vary'),'*');r.vary('Accept-Encoding');assert.equal(r.getHeader('vary'),'*');assert.throws(()=>r.vary(['*','bad name']),TypeError);assert.equal(r.getHeader('vary'),'*');}));
+ await category('empty no-op and no input mutation',()=>scenario(r=>{r.header('vary',['Accept','Accept']);const old=r.getHeader('vary');r.vary(' , \t,');assert.equal(r.getHeader('vary'),old);const values=['Origin','Accept'];r.vary(values);assert.deepEqual(values,['Origin','Accept']);assert.equal(r.getHeader('vary'),'Accept, Origin');}));
+ await category('invalid input atomic incl CRLF',()=>scenario(r=>{r.header('vary','Accept');for(const bad of [null,undefined,7,{},['Origin',3],['Origin',['Accept']],['Origin','bad name'],'Accept\r\n','\nAccept','bad:token']){assert.throws(()=>r.vary(bad),TypeError);assert.equal(r.getHeader('vary'),'Accept');}}));
+ await category('onSend real HTTP',async()=>{const v=await scenario(r=>{r.header('x-other','same');r.vary('Accept-Encoding').vary('Origin');},{real:true,hook:true});assert.equal(v.headers.vary,'Accept-Encoding, Origin');assert.equal(v.headers['x-other'],'same');});
+ }
+ await category('independent requests',async()=>{const app=fastify();app.get('/:id',(req,r)=>{if(task==='append')r.appendHeader('x-test',req.params.id);else r.vary(req.params.id);return 'ok';});try{const a=await app.inject('/Accept'),b=await app.inject('/Origin');assert.equal(String(a.headers[task==='append'?'x-test':'vary']),'Accept');assert.equal(String(b.headers[task==='append'?'x-test':'vary']),'Origin');}finally{await app.close();}});
+ console.log(JSON.stringify({task,passed:rows.filter(x=>x.passed).length,total:rows.length,categories:rows}));
+})().catch(e=>{console.error(e);process.exitCode=2;});

package/tools/repo-pilot/reference.mjs

@@ -0,0 +1,43 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export function reference(cwd, task, mutant=false) {
+ const file=join(cwd,'lib/reply.js');let source=readFileSync(file,'utf8');
+ const code=task==='append'?`
+Reply.prototype.appendHeader = function (name, input) {
+ const { validateHeaderName, validateHeaderValue } = require('node:http')
+ if (typeof name !== 'string') throw new TypeError('Invalid name')
+ validateHeaderName(name)
+ const items = Array.isArray(input) ? input : [input]
+ const values = items.map(value => {
+  if (!(typeof value === 'string' || (typeof value === 'number' && Number.isFinite(value)))) throw new TypeError('Invalid value')
+  validateHeaderValue(name, String(value))
+  return String(value)
+ })
+ if (!values.length) return this
+ const old = this.getHeader(name)
+ const merged = ${mutant?'values':'(old === undefined ? [] : Array.isArray(old) ? [...old] : [old]).concat(values)'}
+ this[kReplyHeaders][name.toLowerCase()] = merged
+ return this
+}
+`: `
+Reply.prototype.vary = function (input) {
+ const items = Array.isArray(input) ? input : [input]
+ const parse = values => values.flatMap(value => {
+  if (typeof value !== 'string' || /[\\r\\n]/.test(value)) throw new TypeError('Invalid Vary')
+  return value.split(',').map(s => s.replace(/^[ \\t]+|[ \\t]+$/g, '')).filter(Boolean).map(token => {
+   if (!/^[!#$%&'*+.^_\x60|~0-9A-Za-z-]+$/.test(token)) throw new TypeError('Invalid field')
+   return token
+  })
+ })
+ const tokens = parse(items)
+ if (!tokens.length) return this
+ const old = this.getHeader('vary')
+ const all = parse(old === undefined ? [] : Array.isArray(old) ? old : [String(old)]).concat(tokens)
+ const seen = new Set(), output = []
+ for (const token of all) { const key = ${mutant?'token':'token.toLowerCase()'}; if (!seen.has(key)) { seen.add(key); output.push(token) } }
+ this.header('vary', seen.has('*') ? '*' : output.join(', '))
+ return this
+}
+`;
+ source=source.replace('Reply.prototype.getHeader = function (key) {',code+'\nReply.prototype.getHeader = function (key) {');writeFileSync(file,source);
+}

package/tools/repo-pilot/runner.mjs

@@ -0,0 +1,85 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { createServer, connect } from 'node:net';
+import { mkdirSync, writeFileSync, readFileSync, appendFileSync, cpSync, readdirSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { startGateway } from '../benchmark/gateway.mjs';
+import { GLM_FLASH as MODEL, generatorProfile } from '../benchmark/generator.mjs';
+const PROFILE = generatorProfile(MODEL);
+import { safeEnv, provisionTools, ENGINE_ROOT, stopGroup, sha } from '../benchmark/runtime.mjs';
+import { initializeCampaign, campaignAccount } from '../benchmark/campaign.mjs';
+import { terminalStatus } from '../benchmark/runner.mjs';
+import { TASKS, MATRIX, BASE } from './tasks.mjs';
+export const ROOT='/home/baissi/benchmarks/glm-repo-pilot-v1';
+const SETUP='/home/baissi/benchmarks/jev-repo-pilot';
+const REPO=resolve(dirname(fileURLToPath(import.meta.url)),'../..');
+const BWRAP=SETUP+'/setup/bubblewrap-root/usr/bin/bwrap';
+const CAMPAIGN='/home/baissi/benchmarks/jev-repo-pilot/campaign.json';
+const NODE=dirname(dirname(process.execPath));
+function walk(root){return readdirSync(root,{withFileTypes:true}).flatMap(e=>e.isDirectory()?walk(join(root,e.name)):e.isFile()?[join(root,e.name)]:[]);}
+export function manifest(){return Object.fromEntries([...['lib','extensions','docs','skills','tools/repo-pilot','tools/benchmark'].flatMap(d=>walk(join(REPO,d))),...walk(ROOT+'/reference'),...walk(ROOT+'/system'),...walk(ROOT+'/setup/fastify').filter(p=>!p.includes('/.git/')), ...walk(ENGINE_ROOT), ...walk(REPO+'/vendor'), ...walk(REPO+'/node_modules'),process.execPath,BWRAP].sort().map(p=>[p,sha(readFileSync(p))]));}
+export function freeze(){writeFileSync(ROOT+'/freeze.json',JSON.stringify({at:new Date().toISOString(),base:BASE,generator:PROFILE,hashes:manifest(),limits:{candidate:14,smoke:1,cell:2.3,seconds:900,tools:120},compaction:{enabled:true,reserveTokens:70000,keepRecentTokens:6000}},null,2),{flag:'wx'});}
+function verify(){const frozen=JSON.parse(readFileSync(ROOT+'/freeze.json'));if(JSON.stringify(frozen.hashes)!==JSON.stringify(manifest()))throw Error('Freeze mismatch');}
+export function sandboxArgs(run, {broker=true,evaluator=false}={}){
+ const args=['--die-with-parent','--new-session','--unshare-user','--unshare-pid','--unshare-ipc','--unshare-uts','--unshare-net','--cap-drop','ALL','--ro-bind','/usr','/usr','--ro-bind','/lib','/lib','--ro-bind','/lib64','/lib64','--symlink','usr/bin','/bin','--proc','/proc','--dev','/dev','--ro-bind',ROOT+'/system/hosts','/etc/hosts','--ro-bind',ROOT+'/system/nsswitch.conf','/etc/nsswitch.conf','--tmpfs','/tmp','--dir','/home','--dir','/home/agent','--ro-bind',NODE,'/node','--ro-bind',ENGINE_ROOT,'/engine','--bind',run+'/workspace','/work','--ro-bind',ROOT+'/setup/fastify/node_modules','/work/node_modules','--bind',run+'/config','/config','--bind',run+'/sessions','/sessions','--bind',run+'/logs','/logs','--ro-bind',ROOT+'/reference','/reference'];
+ for(const d of ['lib','extensions','docs','skills','vendor','node_modules'])args.push('--ro-bind',REPO+'/'+d,'/harness/'+d);
+ args.push('--ro-bind',REPO+'/tools/benchmark/guard.ts','/guard.ts','--ro-bind',REPO+'/tools/repo-pilot/sandbox-entry.mjs','/entry.mjs');
+ if(broker)args.push('--ro-bind',run+'/broker.sock','/broker.sock');
+ if(evaluator)args.push('--ro-bind',REPO+'/tools/repo-pilot/evaluator.cjs','/evaluate.cjs','--ro-bind',ROOT+'/setup/fastify/test','/work/test','--ro-bind',REPO+'/tools/repo-pilot/type-evaluator.cjs','/types.cjs');
+ args.push('--chdir','/work','--clearenv');
+ const env={HOME:'/home/agent',USER:'agent',PATH:'/node/bin:/usr/bin:/bin',LANG:'C.UTF-8',CI:'1',PI_CODING_AGENT_DIR:'/config',PI_OFFLINE:'1',PI_TELEMETRY:'0',BENCH_GUARD_LOG:'/logs/guard.jsonl',BENCH_TOOL_LIMIT:'120'};
+ for(const[k,v]of Object.entries(env))args.push('--setenv',k,v);
+ return args;
+}
+export function prepareRun(name,prompt){
+ const run=ROOT+'/'+name;mkdirSync(run);for(const d of ['config','sessions','logs'])mkdirSync(run+'/'+d);
+ cpSync(ROOT+'/setup/fastify',run+'/workspace',{recursive:true,filter:p=>!p.includes('/node_modules')});
+ writeFileSync(run+'/workspace/TASK.md',prompt);appendFileSync(run+'/workspace/.gitignore','\n.harness/\nartifacts/\n');
+ const git=spawnSync('git',['-c','user.name=Pilot','-c','user.email=pilot@localhost','add','.'],{cwd:run+'/workspace'});if(git.status)throw Error('git add');
+ if(spawnSync('git',['-c','user.name=Pilot','-c','user.email=pilot@localhost','commit','-qm','Frozen pilot task and dependency lock'],{cwd:run+'/workspace'}).status)throw Error('git commit');
+ provisionTools(run+'/config');writeFileSync(run+'/config/auth.json','{}');
+ writeFileSync(run+'/config/settings.json',JSON.stringify({retry:{enabled:false,provider:{maxRetries:0}},compaction:{enabled:true,reserveTokens:70000,keepRecentTokens:6000}}));
+ writeFileSync(run+'/config/models.json',JSON.stringify({providers:{benchmark:{baseUrl:'http://127.0.0.1:12345/v1',api:'openai-completions',apiKey:'local-dummy',models:[{id:MODEL,reasoning:true,input:['text'],contextWindow:100000,maxTokens:16384,cost:{input:PROFILE.input,output:PROFILE.output,cacheRead:PROFILE.cacheRead,cacheWrite:0},compat:{supportsDeveloperRole:false,thinkingFormat:'openrouter',maxTokensField:'max_tokens',supportsStore:false}}]}}}));return run;
+}
+export async function run(task,arm,{smoke=false,prompt:override}={}){
+ if(!smoke)verify();
+ const prompt=override||TASKS[task];const name=smoke?`smoke-${task}-${arm}`:`${task}-${arm}`;
+ const dir=prepareRun(name,prompt);
+ if(smoke && task==='compact')writeFileSync(dir+'/config/settings.json',JSON.stringify({retry:{enabled:false},compaction:{enabled:true,reserveTokens:90000,keepRecentTokens:2000}}));
+ const key=JSON.parse(readFileSync('/home/baissi/.pi/agent/auth.json')).openrouter.key;
+ const gateway=await startGateway({key,generator:MODEL,limit:smoke?.7:2.3,allowJev:arm==='jev',receiptPath:dir+'/gateway.jsonl',account:campaignAccount(CAMPAIGN,smoke?'smoke':'candidate',name)});
+ const port=Number(new URL(gateway.url).port);const connections=new Set();
+ const proxy=createServer(client=>{const upstream=connect(port,'127.0.0.1');connections.add(client);connections.add(upstream);client.pipe(upstream);upstream.pipe(client);for(const s of [client,upstream]){s.on('error',()=>{client.destroy();upstream.destroy();});s.on('close',()=>connections.delete(s));}});
+ await new Promise(r=>proxy.listen(dir+'/broker.sock',r));
+ const args=sandboxArgs(dir);args.push('/node/bin/node','/entry.mjs','/engine/dist/cli.js','--mode','json','-p','--offline','--no-extensions','--no-skills','--no-context-files','--no-prompt-templates','--no-themes','--no-approve','--provider','benchmark','--model',MODEL,'--thinking','high','--session-dir','/sessions','-e','/guard.ts');
+ if(arm!=='plain')args.push('-e','/harness/extensions/delivery.ts','--skill','/harness/skills/software-delivery/SKILL.md','--append-system-prompt','Use delivery_design action=guide for exact schema before authoring design; /harness/docs/tested-planning.md has extended details only if needed. This is an existing library patch: inspect relevant files, submit a concrete plan, use focused edits and preserve upstream tests.');
+ if(arm==='jev')args.push('--delivery-jev','--delivery-jev-broker','http://127.0.0.1:12345/jev');
+ args.push('--tools',['read','bash','edit','write','grep','find','ls',...(arm==='plain'?[]:['delivery_plan','delivery_revise','delivery_design','delivery_progress','delivery_check','delivery_review','delivery_status','delivery_finish'])].join(','),prompt);
+ writeFileSync(dir+'/invocation.json',JSON.stringify({task,arm,generator:PROFILE,base:BASE,args,settings:JSON.parse(readFileSync(dir+'/config/settings.json')),at:new Date().toISOString()},null,2));
+ const started=Date.now(),events=[];let pending='',stopReason=null,count=0;const decoder=new TextDecoder();
+ const child=spawn(BWRAP,args,{env:safeEnv(),stdio:['ignore','pipe','pipe'],detached:true});
+ const kill=reason=>{stopReason ||= reason;try{process.kill(-child.pid,'SIGTERM');}catch{}setTimeout(()=>{try{process.kill(-child.pid,'SIGKILL');}catch{}},2000).unref();};
+ child.stdout.on('data',chunk=>{appendFileSync(dir+'/events.jsonl',chunk);pending+=decoder.decode(chunk,{stream:true});let nl;while((nl=pending.indexOf('\n'))>=0){const line=pending.slice(0,nl);pending=pending.slice(nl+1);try{const e=JSON.parse(line);if(e.type==='message_end')events.push(e);if(e.type==='tool_execution_start')count++;if(e.type==='tool_execution_end'&&e.result?.content?.some(c=>c.text?.includes('Benchmark tool budget exhausted')))kill('tool-budget');}catch{}}});
+ child.stderr.on('data',chunk=>appendFileSync(dir+'/stderr.log',chunk));const timer=setTimeout(()=>kill('wall-time'),(smoke?240:900)*1000);
+ let exit;try{exit=await new Promise((r,j)=>{child.on('error',j);child.on('exit',(code,signal)=>r({code,signal}));});}finally{clearTimeout(timer);await stopGroup(child);for(const s of connections)s.destroy();await new Promise(r=>proxy.close(r));await gateway.close();}
+ const classification=terminalStatus(events,exit,stopReason,gateway.budget);
+ let resource=stopReason;if(gateway.receipts.some(r=>r.type==='failure'&&/input bound/i.test(r.reason||'')))resource='input-byte-limit';if(classification.terminalModelReason==='length')resource='output-token-limit';
+ const result={task,arm,...exit,...classification,resource,wallMs:Date.now()-started,toolStarts:count,budget:gateway.budget};writeFileSync(dir+'/result.json',JSON.stringify(result,null,2));console.log(JSON.stringify(result));return result;
+}
+export function evaluate(task,arm){
+ const dir=ROOT+'/'+task+'-'+arm;const args=sandboxArgs(dir,{broker:false,evaluator:true});
+ const r=spawnSync(BWRAP,[...args,'/node/bin/node','/evaluate.cjs',task],{encoding:'utf8',timeout:60000,maxBuffer:4e6});writeFileSync(dir+'/evaluation.log',r.stdout+r.stderr);
+ const evaluation=r.status===0?JSON.parse(r.stdout.trim()):{infrastructureError:true,status:r.status};
+ const baseline=spawnSync(BWRAP,[...sandboxArgs(dir,{broker:false,evaluator:true}),'/node/bin/node','--test','test/internals/reply.test.js','test/internals/request.test.js'],{encoding:'utf8',timeout:120000,maxBuffer:8e6});writeFileSync(dir+'/regressions.log',baseline.stdout+baseline.stderr);
+ const diff=spawnSync('git',['diff','--stat'],{cwd:dir+'/workspace',encoding:'utf8'}).stdout;
+ const types=spawnSync(BWRAP,[...sandboxArgs(dir,{broker:false,evaluator:true}),'/node/bin/node','/types.cjs',task],{encoding:'utf8',timeout:60000,maxBuffer:4e6});writeFileSync(dir+'/types.log',types.stdout+types.stderr);
+ const result={...evaluation,protectedRegressionExit:baseline.status,externalTypesExit:types.status,diff};writeFileSync(dir+'/evaluation.json',JSON.stringify(result,null,2));return result;
+}
+if(process.argv[1]===fileURLToPath(import.meta.url)){
+ const [action,task,arm]=process.argv.slice(2);
+ if(action==='init')initializeCampaign(CAMPAIGN,{candidateLimit:14,smokeLimit:1,historicalCandidate:0,historicalSmoke:0});
+ else if(action==='freeze')freeze();
+ else if(action==='smoke')await run(task,arm,{smoke:true,prompt:readFileSync(ROOT+'/smoke-prompt.txt','utf8')});
+ else if(action==='matrix'){for(const[t,a]of MATRIX){const r=await run(t,a);evaluate(t,a);if(!r.resource&&['infrastructure-error','process-error','missing-terminal-message','model-error'].includes(r.status))throw Error('Infrastructure stop; no automatic retry');}}
+ else if(action==='evaluate')console.log(evaluate(task,arm));
+}