create-walle 0.10.2 → 0.10.3

package/template/coding-task-manager/public/m/private-api.js

@@ -378,5 +378,35 @@
     }
   }
 
-  return { createMobilePrivateApi, runPhoneModelRequest, createIdentityCache, createConditionalIdentityFetch, CONDITIONAL_PATHS };
+  // The phone transcript page's one normalization: an array, `{messages}`, `{data}` or `{items}` all become
+  // the same page shape. Moved verbatim out of app.js (which is at its line ceiling) — one call site there.
+  function normalizeSessionMessagesPayload(data) {
+    if (Array.isArray(data)) {
+      return {
+        messages: data,
+        hasMore: false,
+        nextOffset: data.length,
+        total: data.length,
+        pageKind: 'messages',
+        conversationBudget: null,
+      };
+    }
+    const messages = Array.isArray(data?.messages)
+      ? data.messages
+      : (Array.isArray(data?.data) ? data.data : (Array.isArray(data?.items) ? data.items : []));
+    return {
+      messages,
+      hasMore: !!(data?.has_more || data?.hasMore),
+      nextOffset: Number.isFinite(Number(data?.next_offset ?? data?.nextOffset))
+        ? Number(data?.next_offset ?? data?.nextOffset)
+        : messages.length,
+      total: Number.isFinite(Number(data?.total)) ? Number(data.total) : messages.length,
+      pageKind: String(data?.page_kind || data?.pageKind || ''),
+      conversationBudget: data?.conversationBudget && typeof data.conversationBudget === 'object'
+        ? data.conversationBudget
+        : null,
+    };
+  }
+
+  return { createMobilePrivateApi, runPhoneModelRequest, createIdentityCache, createConditionalIdentityFetch, CONDITIONAL_PATHS, normalizeSessionMessagesPayload };
 });

package/template/coding-task-manager/public/usage.html

@@ -55,6 +55,7 @@
     <details class="reporting-panel"><summary>Reports and observational budgets</summary><div id="usage-reporting-host"></div></details>
   </main>
   <script src="/js/usage-format.js"></script>
+  <script src="/js/pasted-content.js"></script>
   <script src="/js/session-usage-view.js"></script>
   <script src="/js/usage-reporting-view.js"></script>
   <script>window.CTMSessionUsage.boot(document);</script>

package/template/coding-task-manager/scripts/dev-route-fixture/synthetic-route-upstream.js

@@ -0,0 +1,104 @@
+'use strict';
+
+// WP-5 (coding-task-manager/docs/opencode-followups-agent-word-v2-waiting-dev-route-2026-10-31.html
+// §4 "Synthetic route upstream", §6.5): the ONE loopback synthetic model upstream, extracted
+// verbatim from tests/rendering/helpers/claude-routed-provider.js so that the render harness's
+// routed-provider fixture and scripts/dev-route-fixture.js serve the same bytes from the same code.
+//
+// It is a synthetic upstream, never a provider: no credentials, no real vendor, no private source.
+//   GET  /v1/models           (or /models)            -> the reachability answer a route probe reads
+//   POST /v1/chat/completions (or /chat/completions)  -> a canned assistant turn (SSE when the
+//                                                        request body says stream: true)
+//   anything else                                     -> a bounded JSON 404
+// `requests` records every request it answers (`{ method, url, body, model }`) so a caller can
+// assert what a routed target actually sent. The canned turn is the constant SYNTHETIC_ROUTED_TURN
+// under both the streaming and the non-streaming shape, so a routed turn can never hang here.
+
+const http = require('node:http');
+
+/** The one canned assistant turn; both the SSE delta and the JSON message carry it verbatim. */
+const SYNTHETIC_ROUTED_TURN = 'SYNTHETIC_ROUTED_TURN';
+
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) });
+  res.end(payload);
+}
+
+function listen(server, host = '127.0.0.1') {
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, host, () => resolve(server.address().port));
+  });
+}
+
+/**
+ * Start the synthetic upstream on 127.0.0.1 (an OS-assigned port, never a fixed one -- a fixture
+ * that pinned a port would need a probe-close-rebind, which H-8 forbids).
+ *
+ * @param {{ wireModelId?: string }} [options] the model id this upstream lists and answers as.
+ * @returns {Promise<{ server: import('node:http').Server, port: number,
+ *   requests: Array<{ method: string|undefined, url: string|undefined, body: string, model: string|null }>,
+ *   close: () => Promise<void> }>}
+ */
+async function startSyntheticUpstream(options = {}) {
+  // Every caller names its wire model (the render fixture its WIRE_MODEL_ID, the dev fixture --model);
+  // shipped scripts carry no model id literal (model-roles lint R-4).
+  const wireModelId = String(options.wireModelId || '').trim();
+  if (!wireModelId) throw new TypeError('startSyntheticUpstream: wireModelId required');
+  const requests = [];
+  const server = http.createServer((req, res) => {
+    const chunks = [];
+    req.on('data', (chunk) => chunks.push(chunk));
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString('utf8');
+      let parsed = {};
+      // expected: a body that is not JSON (an empty GET body, a probe) is recorded raw and still
+      // served the canned reply -- this upstream never fails on shape.
+      try { parsed = JSON.parse(raw); } catch { parsed = {}; }
+      requests.push({ method: req.method, url: req.url, body: raw, model: parsed?.model ?? null });
+      if (req.url === '/v1/models' || req.url === '/models') {
+        return sendJson(res, 200, { object: 'list', data: [{ id: wireModelId, object: 'model' }] });
+      }
+      if (req.url === '/v1/chat/completions' || req.url === '/chat/completions') {
+        if (parsed.stream) {
+          res.writeHead(200, { 'Content-Type': 'text/event-stream' });
+          res.write(`data: ${JSON.stringify({ id: 'chatcmpl-synthetic', object: 'chat.completion.chunk',
+            model: wireModelId, choices: [{ index: 0, delta: { role: 'assistant', content: SYNTHETIC_ROUTED_TURN } }] })}\n\n`);
+          res.write(`data: ${JSON.stringify({ id: 'chatcmpl-synthetic', object: 'chat.completion.chunk',
+            model: wireModelId, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\n`);
+          return res.end('data: [DONE]\n\n');
+        }
+        return sendJson(res, 200, { id: 'chatcmpl-synthetic', object: 'chat.completion', model: wireModelId,
+          choices: [{ index: 0, message: { role: 'assistant', content: SYNTHETIC_ROUTED_TURN }, finish_reason: 'stop' }],
+          usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
+      }
+      return sendJson(res, 404, { error: 'not_found', path: req.url });
+    });
+  });
+
+  function close() {
+    return new Promise((resolve, reject) => {
+      // Idempotent: a caller may close explicitly and again from its own finally (or after a
+      // signal handler already ran).
+      if (!server.listening) {
+        if (typeof server.closeAllConnections === 'function') server.closeAllConnections();
+        resolve();
+        return;
+      }
+      // A keep-alive socket from a routed turn would otherwise hold close() open forever.
+      if (typeof server.closeAllConnections === 'function') server.closeAllConnections();
+      server.close((error) => (error ? reject(error) : resolve()));
+    });
+  }
+
+  const port = await listen(server);
+  return { server, port, requests, close };
+}
+
+module.exports = {
+  startSyntheticUpstream,
+  sendJson,
+  listen,
+  SYNTHETIC_ROUTED_TURN,
+};

package/template/coding-task-manager/scripts/dev-route-fixture.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+'use strict';
+
+// WP-5 (coding-task-manager/docs/opencode-followups-agent-word-v2-waiting-dev-route-2026-10-31.html
+// §4 "Synthetic route upstream" / "Provider + registry write endpoints" / "Coding-catalog build",
+// §5 D-9/D-10, §6.5): seed ONE synthetic routed model into a /ctm-dev instance and serve a loopback
+// synthetic upstream for it, so routed model switching can be checked live on a fresh dev DB
+// (bin/dev.sh --fresh deletes the dev databases, so a fresh instance has no routes at all).
+//
+//   node scripts/dev-route-fixture.js --ctm-port <devPort> [--walle-port <n>]
+//                                     [--route-id dev-synthetic] [--model fixture/m-route]
+//                                     [--deadline-ms 7200000]
+//
+// Endpoint choice (§6.5 steps 3-4): CTM's lib/api/walle-bridge.js register() mounts
+//   { method: '*', prefix: '/api/models', handler: handleProxy }
+// whose handleProxy pipes every /api/models* request straight to the instance's own WALL_E_PORT
+// (proxyHttp, CTM never parses the body). Both writes -- and the coding-catalog read, and the
+// teardown DELETE -- therefore go to --ctm-port; --walle-port is accepted, refused when it names the
+// primary pair, and never used for a request.
+//
+// Field names come from the endpoints' own code, never from convenience:
+//   POST /api/models/providers  spreads its body into the Wall-E brain upsertModelProvider
+//     upsertModelProvider({ id, name, type, baseUrl, apiKeyEncrypted, customHeaders, enabled,
+//     caCertPem, maxOutputTokens, reasoningField, reasoningEffortDefault }) -- CAMELCASE; the
+//     snake_case aliases (base_url/api_key/custom_headers) belong to /api/wall-e/setup/provider,
+//     not to this raw upsert route, and would be silently dropped here.
+//   POST /api/models/registry   rejects any key outside MODEL_REGISTRY_POST_ALLOWED_FIELDS
+//     (wall-e/http/model-admin.js:77) with 400 `unknown field: <key>`, so this script sends that
+//     allowlist's spellings only.
+//   type 'openai-compatible' is what wall-e/llm/worker-route.js upstreamApisForRow() treats as
+//     routable on the openai-chat wire (the everything-else branch) -- the same type the render
+//     fixture's routeRow() uses.
+//
+// Exit codes: 0 clean shutdown (SIGTERM/SIGINT/--deadline-ms) after the teardown DELETE;
+//   2 refused with NOT ONE request sent (missing --ctm-port, a primary --ctm-port/--walle-port, a
+//     port that is not a reachable dev CTM); 3 the coding catalog never listed a route for
+//     --route-id within 30 s (the catalog warnings are printed); 4 a write/read handshake failed.
+//
+// This script performs no filesystem I/O at all: it never reads or writes ~/.walle/data or any path
+// outside the OS temp dir (the dev instance owns its own data dir).
+
+const { startSyntheticUpstream } = require('./dev-route-fixture/synthetic-route-upstream');
+
+// D-10: the user's live primary pair. Refused before any request, by either flag.
+const PRIMARY_PORTS = new Set([3456, 3457]);
+
+const POLL_INTERVAL_MS = 1000;
+const POLL_DEADLINE_MS = 30_000;
+const REQUEST_TIMEOUT_MS = 10_000;
+const STATUS_TIMEOUT_MS = 5_000;
+const PAGE_SIZE = 500;
+const MAX_CATALOG_PAGES = 50;
+const API_KEY = 'dev-synthetic-not-a-secret';
+
+const DEFAULTS = Object.freeze({
+  routeId: 'dev-synthetic',
+  model: 'fixture/m-route',
+  deadlineMs: 7_200_000,
+});
+
+const FLAG_FIELDS = new Map([
+  ['--ctm-port', 'ctmPort'],
+  ['--walle-port', 'wallePort'],
+  ['--route-id', 'routeId'],
+  ['--model', 'model'],
+  ['--deadline-ms', 'deadlineMs'],
+]);
+
+/** A refusal (exit 2) or a handshake failure (exit 4) carrying the exit code its caller must use. */
+class FixtureFailure extends Error {
+  constructor(exitCode, message) {
+    super(message);
+    this.name = 'FixtureFailure';
+    this.exitCode = exitCode;
+  }
+}
+
+function usageLine() {
+  return 'usage: node scripts/dev-route-fixture.js --ctm-port <devPort> [--walle-port <n>] '
+    + '[--route-id dev-synthetic] [--model fixture/m-route] [--deadline-ms 7200000]';
+}
+
+function messageOf(error) {
+  return String(error?.message || error);
+}
+
+// REPORT + EXIT: every refusal is printed with the usage line and ends the process before the first
+// network request (D-10). Never a throw the caller could swallow into a later request.
+function refuse(message) {
+  process.stderr.write(`dev-route-fixture: refusing: ${message}\n${usageLine()}\n`);
+  process.exit(2);
+}
+
+function parsePort(raw, flag) {
+  if (raw === null || raw === undefined || raw === '') refuse(`${flag} needs a port number`);
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) refuse(`${flag} must be a port number (got ${JSON.stringify(raw)})`);
+  if (PRIMARY_PORTS.has(port)) refuse(`${flag} ${port} is the user's PRIMARY instance -- this fixture is dev-only (D-10)`);
+  return port;
+}
+
+// Accepts `--flag value` and `--flag=value`; an unknown flag or a missing value refuses (a typo
+// silently changing which instance is seeded would be worse than a refusal).
+function parseArgs(argv) {
+  const args = { ...DEFAULTS, ctmPort: null, wallePort: null };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    const eq = token.indexOf('=');
+    const flag = eq === -1 ? token : token.slice(0, eq);
+    const field = FLAG_FIELDS.get(flag);
+    if (!field) refuse(`unknown argument ${JSON.stringify(token)}`);
+    let value = eq === -1 ? null : token.slice(eq + 1);
+    if (value === null) {
+      index += 1;
+      value = index < argv.length ? argv[index] : null;
+      if (value === null || value.startsWith('--')) refuse(`${flag} needs a value`);
+    }
+    args[field] = value;
+  }
+  args.ctmPort = parsePort(args.ctmPort, '--ctm-port');
+  args.wallePort = args.wallePort === null ? null : parsePort(args.wallePort, '--walle-port');
+  const deadlineMs = Number(args.deadlineMs);
+  if (!Number.isInteger(deadlineMs) || deadlineMs < 1_000) refuse(`--deadline-ms must be an integer >= 1000 (got ${JSON.stringify(args.deadlineMs)})`);
+  args.deadlineMs = deadlineMs;
+  args.model = String(args.model ?? '').trim();
+  if (!args.model) refuse('--model must not be empty');
+  args.routeId = String(args.routeId ?? '').trim();
+  if (!/^[A-Za-z0-9._:-]{1,80}$/.test(args.routeId)) refuse(`--route-id must match [A-Za-z0-9._:-]{1,80} (got ${JSON.stringify(args.routeId)})`);
+  return args;
+}
+
+function ctmBase(ctmPort) {
+  return `http://127.0.0.1:${ctmPort}`;
+}
+
+// D-10 step 1: the port must really be a running CTM instance. Anything else refuses with no write.
+async function requireDevInstance(ctmPort) {
+  const base = ctmBase(ctmPort);
+  let res = null;
+  let body = null;
+  try {
+    res = await fetch(`${base}/api/services/status`, { signal: AbortSignal.timeout(STATUS_TIMEOUT_MS) });
+    // expected: a non-JSON body is not a CTM status payload -- handled as `body = null` below, and
+    // read as a refusal rather than used.
+    try { body = await res.json(); } catch { body = null; }
+  } catch (error) {
+    // REPORT + EXIT 2: nothing answered, so there is nothing to seed and nothing was sent.
+    refuse(`GET ${base}/api/services/status failed: ${messageOf(error)}`);
+  }
+  if (!res.ok) refuse(`GET ${base}/api/services/status -> HTTP ${res.status}`);
+  if (!body || body.ctm?.running !== true) refuse(`GET ${base}/api/services/status did not answer as a running CTM instance`);
+}
+
+async function postJson(url, body, what) {
+  let res = null;
+  try {
+    res = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+  } catch (error) {
+    throw new FixtureFailure(4, `${what}: POST ${url} failed: ${messageOf(error)}`);
+  }
+  const text = await res.text();
+  if (!res.ok) throw new FixtureFailure(4, `${what}: POST ${url} -> HTTP ${res.status} ${text.slice(0, 400)}`);
+  return text;
+}
+
+async function getJson(url) {
+  let res = null;
+  let body = null;
+  try {
+    res = await fetch(url, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+    // expected: an error body that is not JSON is reported as the raw status line, never parsed.
+    try { body = await res.json(); } catch { body = null; }
+  } catch (error) {
+    throw new FixtureFailure(4, `GET ${url} failed: ${messageOf(error)}`);
+  }
+  if (!res.ok) throw new FixtureFailure(4, `GET ${url} -> HTTP ${res.status} ${body ? JSON.stringify(body).slice(0, 300) : ''}`);
+  return body;
+}
+
+// The provider row as the raw upsert route reads it (see the field-name note in the header).
+function providerBody(args, upstreamPort) {
+  return {
+    id: args.routeId,
+    name: 'Dev synthetic',
+    type: 'openai-compatible',
+    baseUrl: `http://127.0.0.1:${upstreamPort}/v1`,
+    apiKeyEncrypted: API_KEY,
+    enabled: 1,
+  };
+}
+
+// The registry entry: MODEL_REGISTRY_POST_ALLOWED_FIELDS spellings only (id, providerId, modelId,
+// displayName, capabilities, enabled, maxContextTokens, maxOutputTokens, source, verificationStatus).
+function registryBody(args) {
+  return {
+    id: `${args.routeId}:${args.model}`,
+    providerId: args.routeId,
+    modelId: args.model,
+    displayName: `${args.model} (dev synthetic)`,
+    capabilities: ['chat', 'tools'],
+    enabled: 1,
+    maxContextTokens: 131072,
+    maxOutputTokens: 8192,
+    source: 'manual',
+    verificationStatus: 'verified',
+  };
+}
+
+function itemHasRoute(item, routeId) {
+  return Array.isArray(item?.routes) && item.routes.some((route) => route?.provider_id === routeId);
+}
+
+// One full paged walk of GET /api/models/coding-catalog, following next_page_token to the end the
+// same way lib/walle-paged-read.js requestWalleAllPages does (a partial walk is never a verdict).
+async function readCatalog(base) {
+  const items = [];
+  const warnings = [];
+  const seenTokens = new Set();
+  let token = '';
+  for (let page = 0; page < MAX_CATALOG_PAGES; page += 1) {
+    const query = new URLSearchParams({ page_size: String(PAGE_SIZE) });
+    if (token) query.set('page_token', token);
+    const body = await getJson(`${base}/api/models/coding-catalog?${query.toString()}`);
+    if (!Array.isArray(body?.models)) throw new FixtureFailure(4, 'GET /api/models/coding-catalog answered without a models array');
+    items.push(...body.models);
+    for (const warning of Array.isArray(body.catalog_warnings) ? body.catalog_warnings : []) warnings.push(warning);
+    if (typeof body.next_page_token !== 'string' || !body.next_page_token) return { items, warnings };
+    if (seenTokens.has(body.next_page_token)) throw new FixtureFailure(4, 'GET /api/models/coding-catalog repeated a next_page_token');
+    seenTokens.add(body.next_page_token);
+    token = body.next_page_token;
+  }
+  throw new FixtureFailure(4, `GET /api/models/coding-catalog did not finish within ${MAX_CATALOG_PAGES} pages`);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => { setTimeout(resolve, ms); });
+}
+
+// §6.5 step 4: poll every second for up to 30 s; the deadline is the loop's own bound, never a set
+// number of attempts.
+async function waitForCatalogRoute(base, routeId) {
+  const deadline = Date.now() + POLL_DEADLINE_MS;
+  for (;;) {
+    const catalog = await readCatalog(base);
+    if (catalog.items.some((item) => itemHasRoute(item, routeId))) return { ...catalog, found: true };
+    if (Date.now() >= deadline) return { ...catalog, found: false };
+    await sleep(POLL_INTERVAL_MS);
+  }
+}
+
+// §6.5 step 5: undo the provider row, then release the upstream. REPORT-only -- a cleanup that
+// cannot reach a dev instance must never turn into a hang or hide the port release.
+async function teardown({ base, routeId, upstream, deleteProvider }) {
+  if (deleteProvider) {
+    try {
+      const res = await fetch(`${base}/api/models/providers/${encodeURIComponent(routeId)}`, {
+        method: 'DELETE',
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+      });
+      if (!res.ok) process.stderr.write(`dev-route-fixture: DELETE provider ${routeId} -> HTTP ${res.status}\n`);
+    } catch (error) {
+      // REPORT: the dev instance may already be gone; the row dies with its database.
+      process.stderr.write(`dev-route-fixture: DELETE provider ${routeId} failed: ${messageOf(error)}\n`);
+    }
+  }
+  try {
+    await upstream.close();
+  } catch (error) {
+    // REPORT: a port that will not close is worth the line; there is nothing left to release it with.
+    process.stderr.write(`dev-route-fixture: closing the synthetic upstream failed: ${messageOf(error)}\n`);
+  }
+}
+
+function waitForShutdown(deadlineMs) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => resolve(`deadline ${deadlineMs}ms reached`), deadlineMs);
+    const stop = (signal) => {
+      clearTimeout(timer);
+      resolve(`received ${signal}`);
+    };
+    process.once('SIGTERM', () => stop('SIGTERM'));
+    process.once('SIGINT', () => stop('SIGINT'));
+  });
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const base = ctmBase(args.ctmPort);
+  await requireDevInstance(args.ctmPort);
+  const upstream = await startSyntheticUpstream({ wireModelId: args.model });
+  let providerWritten = false;
+  try {
+    await postJson(`${base}/api/models/providers`, providerBody(args, upstream.port), 'provider write');
+    providerWritten = true;
+    await postJson(`${base}/api/models/registry`, registryBody(args), 'registry write');
+    const catalog = await waitForCatalogRoute(base, args.routeId);
+    if (!catalog.found) {
+      for (const warning of catalog.warnings) {
+        process.stderr.write(`dev-route-fixture: catalog warning ${JSON.stringify(warning)}\n`);
+      }
+      process.stdout.write(`${JSON.stringify({
+        error: 'catalog_route_missing', ctm_port: args.ctmPort, route_id: args.routeId, warnings: catalog.warnings,
+      })}\n`);
+      await teardown({ base, routeId: args.routeId, upstream, deleteProvider: true });
+      process.exit(3);
+    }
+  } catch (error) {
+    // HANDLE + REPORT: undo the partial seed, then exit non-zero -- a half-seeded route must never
+    // be reported as success.
+    process.stderr.write(`dev-route-fixture: ${messageOf(error)}\n`);
+    await teardown({ base, routeId: args.routeId, upstream, deleteProvider: providerWritten });
+    process.exit(error?.exitCode || 4);
+  }
+  // `requests_log` is the synthetic upstream's live request log at print time (empty on a fresh
+  // start; the upstream itself records what a routed turn actually sent).
+  process.stdout.write(`${JSON.stringify({
+    ctm_port: args.ctmPort,
+    route_id: args.routeId,
+    model: args.model,
+    upstream_port: upstream.port,
+    requests_log: upstream.requests,
+  })}\n`);
+  const stopped = await waitForShutdown(args.deadlineMs);
+  await teardown({ base, routeId: args.routeId, upstream, deleteProvider: true });
+  process.stderr.write(`dev-route-fixture: ${stopped}; provider ${args.routeId} deleted\n`);
+  process.exit(0);
+}
+
+main().catch((error) => {
+  // REPORT: anything reaching here is a bug in this script (a refusal already called process.exit),
+  // never a dev-instance state the caller can act on.
+  process.stderr.write(`dev-route-fixture: unexpected failure: ${error?.stack || error}\n`);
+  process.exit(4);
+});