@matuto-ai/opencode-psst-connector 0.0.0-stage → 0.6.0

package/src/message-format.mjs

@@ -0,0 +1,26 @@
+import { canonical, validateEnvelope } from '../vendor/broker/src/protocol.mjs';
+import { provenance as legacyProvenance } from '../vendor/broker/reference/runtime.mjs';
+import { LocalError } from '../vendor/broker/reference/errors.mjs';
+
+export const NATIVE_FORMAT = 'compact-v1';
+
+// Versioned presentation only. Wire validation/authenticated origin and native
+// custom-message role are unchanged. Do not change compact-v1 after publication:
+// persisted handoffs must reconcile against the exact format originally sent.
+export function nativeMessage(rawEnvelope, format = NATIVE_FORMAT) {
+  if (format === null || format === 'legacy-v1') return legacyProvenance(rawEnvelope);
+  if (format !== NATIVE_FORMAT) throw new LocalError('invalid_configuration');
+  const envelope = validateEnvelope(rawEnvelope);
+  const sender = { name: envelope.sender.name, client_type: envelope.sender.client_type };
+  if (envelope.sender.project?.trim()) sender.project = envelope.sender.project;
+  const model = {};
+  for (const key of ['provider', 'id']) if (envelope.sender.model[key]?.trim()) model[key] = envelope.sender.model[key];
+  if (Object.keys(model).length) sender.model = { ...model, source: envelope.sender.model.source };
+  const data = { message_id: envelope.message_id, sender, text: envelope.content.text };
+  if (envelope.correlation_id) data.correlation_id = envelope.correlation_id;
+  if (envelope.reply_to_message_id) data.reply_to_message_id = envelope.reply_to_message_id;
+  // ASCII controls are JSON escaped; escape terminal/bidi controls as well.
+  const escaped = canonical(data).replace(/[\u007f-\u009f\u2028\u2029\u202a-\u202e\u2066-\u2069]/gu,
+    char => `\\u${char.codePointAt(0).toString(16).padStart(4, '0')}`);
+  return `Broker message from AI agent ${envelope.sender.client_id}\n${escaped}`;
+}

package/src/message-preview.mjs

@@ -0,0 +1,29 @@
+import { validateEnvelope } from '../vendor/broker/src/protocol.mjs';
+
+export const PREVIEW_TEXT_LIMIT = 160;
+export const PREVIEW_SENDER_LIMIT = 40;
+// This is a presentation-only preview, not a replacement for the full compact-v1
+// body. Persist it with each new admission; never recompute a stored payload.
+const unsafe = /[\u0000-\u001f\u007f-\u009f\u2028\u2029\u200b\u2060\ufeff]|\p{Bidi_Control}/u;
+function literal(value, limit) {
+  const tokens = []; let length = 0;
+  for (const char of value) {
+    const token = char === '\\' ? '\\\\' : unsafe.test(char)
+      ? `\\u${char.codePointAt(0).toString(16).padStart(4, '0')}` : char;
+    const size = [...token].length;
+    if (length + size > limit) {
+      while (length >= limit) length -= [...tokens.pop()].length;
+      return tokens.join('') + '…';
+    }
+    tokens.push(token); length += size;
+  }
+  return tokens.join('');
+}
+
+/** Literal external-agent notice for the native history; no semantic summary. */
+export function nativeDescription(rawEnvelope) {
+  const envelope = validateEnvelope(rawEnvelope);
+  const sender = literal(envelope.sender.name, PREVIEW_SENDER_LIMIT);
+  const preview = literal(envelope.content.text, PREVIEW_TEXT_LIMIT);
+  return `Psst · new message · From: ${sender} · ${envelope.sender.client_type} · ${preview}`;
+}

package/src/native-delivery.mjs

@@ -0,0 +1,169 @@
+import { createPresenceNotices } from './presence-notices.mjs';
+import { randomUUID } from 'node:crypto';
+import { canonical } from '../vendor/broker/src/protocol.mjs';
+import { nativeMessage, NATIVE_FORMAT } from './message-format.mjs';
+import { nativeDescription } from './message-preview.mjs';
+
+export const HOST_VERSION = '2.2.5';
+const id = value => typeof value === 'string' && /^[A-Za-z0-9_.:-]{1,256}$/.test(value);
+export function nativeSessionBinding(info, hostID) {
+  if (!id(info?.id) || !id(hostID) || !id(info?.projectID)
+    || !Number.isSafeInteger(info?.time?.created) || info.time.created <= 0
+    || typeof info?.location?.directory !== 'string' || !info.location.directory.startsWith('/')) throw new Error('native_session_binding_unavailable');
+  return { hostID, sessionID: info.id, created: info.time.created, projectID: info.projectID,
+    location: { directory: info.location.directory, ...(info.location.workspaceID ? { workspaceID: info.location.workspaceID } : {}) } };
+}
+
+/** Native OpenCode queue admission, never classic promptAsync or a human-role prompt.
+ * A successful receipt means durable native admission, NOT model consumption.
+ * No mutation retry: native cancellation removes its idempotency lookup row.
+ */
+export function createNativeDelivery({ session, inbox, binding, signal, verify, client, noticeNow, available = () => true, interval = 250,
+  requestTimeout = 2000, onDiagnostic = () => {} }) {
+  if (!session || ['synthetic', 'context'].some(key => typeof session[key] !== 'function')
+    || !(signal instanceof AbortSignal) || typeof verify !== 'function' || typeof available !== 'function' || !id(binding?.sessionID)
+    || !Number.isSafeInteger(interval) || interval < 10 || interval > 60000
+    || !Number.isSafeInteger(requestTimeout) || requestTimeout < 10 || requestTimeout > 30000) throw new Error('native_capability_unavailable');
+  inbox.transaction(() => inbox.db.exec('CREATE TABLE IF NOT EXISTS v2_state(key TEXT PRIMARY KEY, value TEXT NOT NULL)'));
+  const getState = key => { inbox.assertUsable(); const row = inbox.db.prepare('SELECT value FROM v2_state WHERE key=?').get(key); return row ? JSON.parse(row.value) : null; };
+  const setState = (key, value) => inbox.transaction(() => inbox.db.prepare('INSERT INTO v2_state(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value').run(key, canonical(value)));
+  const persisted = getState('v2_binding');
+  if (persisted && canonical(persisted) !== canonical(binding)) throw new Error('native_session_mismatch');
+  if (!persisted) setState('v2_binding', binding);
+  inbox.transaction(() => inbox.db.exec(`CREATE TABLE IF NOT EXISTS v2_submissions (
+    broker_message_id TEXT PRIMARY KEY REFERENCES inbox(message_id) ON DELETE CASCADE,
+    native_id TEXT NOT NULL UNIQUE, injection_id TEXT NOT NULL, payload TEXT NOT NULL,
+    promoted INTEGER NOT NULL DEFAULT 0)`));
+  let stopped = false, running, timer, epoch = 0;
+  const active = () => !stopped && !signal.aborted && available();
+  const diagnostic = code => { try { onDiagnostic({ code }); } catch {} };
+  async function call(method, input, permitted = active) {
+    const bounded = AbortSignal.any([signal, AbortSignal.timeout(requestTimeout)]);
+    let listener;
+    try {
+      return await Promise.race([
+        Promise.resolve().then(() => { if (bounded.aborted || !permitted()) throw new Error('native_request_aborted'); return method(input, { signal: bounded }); }),
+        new Promise((_, reject) => { listener = () => reject(new Error('native_request_incomplete'));
+          if (bounded.aborted) listener(); else bounded.addEventListener('abort', listener, { once: true }); }),
+      ]);
+    } finally { bounded.removeEventListener('abort', listener); }
+  }
+  async function current() {
+    if (!active()) return null;
+    const info = await verify();
+    if (!active() || !info || canonical(nativeSessionBinding(info, binding.hostID)) !== canonical(binding)
+      || info.revert || info.time?.archived) return null;
+    return info;
+  }
+  function exactPayload(candidate, target) {
+    return candidate && canonical(candidate) === target.payload;
+  }
+  function exactAdmission(receipt, target) {
+    return receipt?.id === target.native_id && receipt.sessionID === binding.sessionID
+      && receipt.type === 'synthetic' && receipt.delivery === 'queue' && exactPayload(receipt.payload, target);
+  }
+  function exactContext(message, target) {
+    return message?.id === target.native_id && message.type === 'synthetic'
+      && exactPayload({ text: message.text, description: message.description, metadata: message.metadata }, target);
+  }
+  async function contextProof(target) {
+    const messages = await call(session.context.bind(session), { sessionID: binding.sessionID });
+    if (!Array.isArray(messages)) return false;
+    return messages.some(message => exactContext(message, target));
+  }
+  function accept(head, target) {
+    inbox.recordNativeAcceptance(head.message_id, target.injection_id, {
+      accepted: true, receipt_id: `${binding.sessionID}/${target.native_id}`,
+    });
+  }
+  async function deliver() {
+    const observedEpoch = epoch;
+    const info = await current();
+    if (!info) return;
+    // Interrupt/failure is durable across reload. Never wake a cancelled or
+    // failed session just because the broker has another pending envelope.
+    const idle = info.time.idle ?? 0, busy = info.time.busy ?? 0;
+    if (['interrupted', 'failed'].includes(info.outcome) && idle >= busy || getState('v2_paused')) return;
+    const head = inbox.head();
+    if (!head) return;
+    if (head.state !== 'pending') {
+      const target = inbox.db.prepare('SELECT * FROM v2_submissions WHERE broker_message_id=?').get(head.message_id);
+      if (!target || target.injection_id !== head.injection_id) return;
+      if (await contextProof(target) && active() && observedEpoch === epoch && await current()) {
+        accept(head, target);
+        inbox.transaction(() => inbox.db.prepare('UPDATE v2_submissions SET promoted=1 WHERE broker_message_id=?').run(head.message_id));
+        diagnostic('native_admission_reconciled');
+      }
+      return;
+    }
+    // Bound native backlog to one outstanding item. A lost delivered event is
+    // recovered by exact read-only context inspection, never another submit.
+    const outstanding = inbox.db.prepare('SELECT * FROM v2_submissions WHERE promoted=0 ORDER BY rowid LIMIT 1').get();
+    if (outstanding) {
+      if (!await contextProof(outstanding)) return;
+      if (!active() || observedEpoch !== epoch || !await current()) return;
+      inbox.transaction(() => inbox.db.prepare('UPDATE v2_submissions SET promoted=1 WHERE broker_message_id=?').run(outstanding.broker_message_id));
+    }
+    if (!active() || observedEpoch !== epoch || !await current()) return;
+    const payload = { text: nativeMessage(head.envelope), description: nativeDescription(head.envelope), metadata: {
+      source: 'psst', broker_message_id: head.message_id, sender_client_id: head.envelope.sender.client_id, format: NATIVE_FORMAT,
+    } };
+    const target = { native_id: 'msg_psst_' + randomUUID().replaceAll('-', ''), injection_id: randomUUID(), payload: canonical(payload) };
+    // State and exact immutable payload are committed atomically before effect.
+    inbox.transaction(() => {
+      const now = inbox.head();
+      if (now?.message_id !== head.message_id || now.state !== 'pending') throw new Error('native_inbox_changed');
+      inbox.db.prepare('INSERT INTO v2_submissions(broker_message_id,native_id,injection_id,payload) VALUES(?,?,?,?)')
+        .run(head.message_id, target.native_id, target.injection_id, target.payload);
+      inbox.db.prepare("UPDATE inbox SET state='injecting',injection_id=? WHERE message_id=?").run(target.injection_id, head.message_id);
+    }, { growth: Buffer.byteLength(target.payload) * 2 + 8192 });
+    // Even an aborted request may have reached the server. Leave its journal
+    // pinned, including on timeout, exception, cancellation or payload mismatch.
+    let invoked = false;
+    const notInvoked = () => inbox.transaction(() => {
+      const row = inbox.head();
+      if (row?.message_id !== head.message_id || row.state !== 'injecting' || row.injection_id !== target.injection_id) throw new Error('native_inbox_changed');
+      inbox.db.prepare("UPDATE inbox SET state='pending',injection_id=NULL WHERE message_id=?").run(head.message_id);
+      inbox.db.prepare('DELETE FROM v2_submissions WHERE broker_message_id=? AND injection_id=?').run(head.message_id, target.injection_id);
+    });
+    if (!active() || observedEpoch !== epoch) { notInvoked(); return; }
+    try {
+      const receipt = await call((...args) => { invoked = true; return session.synthetic(...args); }, { sessionID: binding.sessionID,
+        id: target.native_id, ...payload, delivery: 'queue', resume: true }, () => active() && observedEpoch === epoch);
+      if (!active() || observedEpoch !== epoch || !await current()) return;
+      if (!exactAdmission(receipt, target)) { diagnostic('native_receipt_mismatch'); return; }
+      accept(head, target);
+      diagnostic('native_admission_confirmed');
+    } catch {
+      if (!invoked) { notInvoked(); diagnostic('native_admission_deferred'); }
+      else diagnostic('native_admission_uncertain');
+    }
+  }
+  const notices = client ? createPresenceNotices({ client, inbox, session, binding, diagnostic, now: noticeNow,
+    call: (method, input) => { const observedEpoch = epoch;
+      return call(method, input, () => active() && epoch === observedEpoch && !getState('v2_paused')); },
+    permitted: async () => {
+      const info = await current();
+      return !!info && !getState('v2_paused') && !(['interrupted', 'failed'].includes(info.outcome)
+        && (info.time.idle ?? 0) >= (info.time.busy ?? 0));
+    } }) : null;
+  function tick() {
+    if (!active() || running) return running;
+    running = Promise.resolve().then(deliver).then(() => notices?.tick()).catch(() => diagnostic('native_delivery_paused')).finally(() => { running = null; });
+    return running;
+  }
+  return {
+    tick,
+    start() { if (!timer && active()) { timer = setInterval(tick, interval); timer.unref?.(); } },
+    event(event) {
+      if (!active() || event?.data?.sessionID !== binding.sessionID) return;
+      if (['session.execution.interrupted', 'session.execution.failed', 'session.inbox.cancelled', 'session.revert.staged'].includes(event.type)) {
+        epoch++; setState('v2_paused', event.type); diagnostic('native_delivery_paused');
+      }
+      // Only host-started work, not an idle poll, can reopen cancellation.
+      if (event.type === 'session.execution.started') setState('v2_paused', null);
+      if (['session.deleted', 'session.moved', 'session.archived'].includes(event.type)) { epoch++; stopped = true; clearInterval(timer); }
+    },
+    async stop() { stopped = true; epoch++; clearInterval(timer); await running; },
+  };
+}

package/src/native-inbox.mjs

@@ -0,0 +1,37 @@
+import { createHash } from 'node:crypto';
+import { openSync, closeSync, readFileSync, writeFileSync, fsyncSync, fstatSync, constants, lstatSync } from 'node:fs';
+import { join } from 'node:path';
+import { canonical } from '../vendor/broker/src/protocol.mjs';
+import { privateDirectory } from './config.mjs';
+
+/** Reopen only this installation + native server store + exact native session.
+ * Exclusive Inbox ownership protects concurrent owners. Never reset a partial,
+ * foreign or unreadable manifest: its broker/native effects may be unknown.
+ */
+export function openNativeInbox({ reference, settings, binding, incarnationOwner = false }) {
+  const key = createHash('sha256').update(canonical({ binding, broker: settings.broker.url })).digest('hex');
+  const directory = privateDirectory(join(privateDirectory(settings.stateDirectory), 'opencode-v2-' + key));
+  if (!incarnationOwner) {
+    try { lstatSync(join(directory, 'current-incarnation.json')); throw new Error('native_incarnation_required'); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  const path = join(directory, 'binding.json');
+  let fd;
+  try {
+    fd = openSync(path, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW, 0o600);
+    writeFileSync(fd, canonical({ version: 1, binding, broker: settings.broker.url, identity: reference.newSessionIdentity('opencode') }) + '\n');
+    fsyncSync(fd); closeSync(fd); fd = undefined;
+    const parent = openSync(directory, constants.O_RDONLY); try { fsyncSync(parent); } finally { closeSync(parent); }
+  } catch (error) { if (error.code !== 'EEXIST') throw error; }
+  finally { if (fd !== undefined) closeSync(fd); }
+  fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  let manifest;
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.mode & 0o077 || stat.size > 8192 || process.getuid && stat.uid !== process.getuid()) throw new Error('native_binding_unavailable');
+    manifest = JSON.parse(readFileSync(fd, 'utf8'));
+  } finally { closeSync(fd); }
+  if (manifest.version !== 1 || manifest.broker !== settings.broker.url || canonical(manifest.binding) !== canonical(binding)
+    || Object.keys(manifest).sort().join(',') !== 'binding,broker,identity,version') throw new Error('native_binding_mismatch');
+  return new reference.Inbox({ directory, identity: manifest.identity });
+}

package/src/native-incarnation.mjs

@@ -0,0 +1,67 @@
+import { randomUUID } from 'node:crypto';
+import { openSync, closeSync, fstatSync, readFileSync, writeFileSync, fsyncSync, renameSync, lstatSync, constants } from 'node:fs';
+import { join } from 'node:path';
+import { canonical, validateUuid } from '../vendor/broker/src/protocol.mjs';
+import { openNativeInbox } from './native-inbox.mjs';
+
+/** Retain the ORIGINAL Inbox owner.sqlite lock throughout every incarnation.
+ * Old workers therefore cannot reopen the old root while a v2 child is active.
+ * Only a proven self-session404 permits replacement; native pending work stays
+ * in its original journal. Pointer uncertainty is terminal for this owner.
+ */
+export function openNativeIncarnation({reference, settings, binding}) {
+  if(settings.broker.registrationVersion!==2 || typeof reference.BrokerClient?.prototype?.createReplacementInbox !== 'function') throw new Error('native_incarnation_required');
+  const root=openNativeInbox({reference,settings,binding,incarnationOwner:true});
+  const closeRoot=root.close.bind(root);root.close=()=>{};
+  const closers=new WeakMap([[root,closeRoot]]);
+  const retain=inbox=>{closers.set(inbox,inbox.close.bind(inbox));inbox.close=()=>{};return inbox;};
+  let current=root, stopped=false, uncertain=false, replacing=false;
+  const path=join(root.directory,'current-incarnation.json');
+  try {
+    let pointer;
+    try { const fd=openSync(path,constants.O_RDONLY|constants.O_NOFOLLOW);
+      try { const s=fstatSync(fd);if(!s.isFile()||s.mode&0o077||s.size>8192||process.getuid&&s.uid!==process.getuid())throw new Error('native_incarnation_invalid');pointer=JSON.parse(readFileSync(fd,'utf8')); }finally{closeSync(fd);}
+    } catch(error) {if(error.code!=='ENOENT')throw error;}
+    if(pointer) {
+      if(pointer.version!==1||Object.keys(pointer).sort().join(',')!=='generation,identity,version'||Object.keys(pointer.identity??{}).sort().join(',')!=='client_id,client_type,session_instance_id'||pointer.identity.client_type!=='opencode')throw new Error('native_incarnation_invalid');
+      validateUuid(pointer.generation);validateUuid(pointer.identity.client_id);validateUuid(pointer.identity.session_instance_id);
+      const directory=join(root.directory,'incarnation-'+pointer.generation);
+      const dir=lstatSync(directory), db=lstatSync(join(directory,'inbox.sqlite'));
+      if(!dir.isDirectory()||dir.isSymbolicLink()||!db.isFile()||db.isSymbolicLink())throw new Error('native_incarnation_invalid');
+      current=retain(new reference.Inbox({directory,identity:pointer.identity}));
+    }
+  }catch(error){closeRoot();throw error;}
+  return {
+    get inbox(){if(stopped||uncertain)throw new Error('native_incarnation_unavailable');return current;},
+    async replace({client,verifySession,signal}) {
+      if(stopped||uncertain||replacing||client.inbox!==current||client.registrationVersion!==2||!client.expiredIdentityConfirmed)throw new Error('native_incarnation_unavailable');
+      replacing=true;
+      try {
+      const generation=randomUUID();
+      let next;
+      try { next=await client.createReplacementInbox({directory:join(root.directory,'incarnation-'+generation),verifySession,signal}); }
+      catch(error) {
+        // Native mismatch is rejected before mkdir by the reviewed helper. Other
+        // failures may leave a partial directory; require deliberate recovery.
+        if(error.code==='session_mismatch')throw error;
+        uncertain=true;throw Object.assign(new Error('native_incarnation_uncertain',{cause:error}),{code:'native_incarnation_uncertain'});
+      }
+      try {
+        if(stopped||signal?.aborted||await verifySession(client.identity)!==true)throw new Error('native_session_mismatch');
+        uncertain=true;
+        const child=openSync(next.directory,constants.O_RDONLY);try{fsyncSync(child);}finally{closeSync(child);}
+        const temporary=join(root.directory,`current-incarnation-${randomUUID()}.tmp`);
+        // From the first pointer write onward, uncertainty forbids all further
+        // allocations/registration in this owner. Reopen reads the durable pointer.
+        const fd=openSync(temporary,constants.O_WRONLY|constants.O_CREAT|constants.O_EXCL|constants.O_NOFOLLOW,0o600);
+        try{writeFileSync(fd,canonical({version:1,generation,identity:next.identity})+'\n');fsyncSync(fd);}finally{closeSync(fd);}
+        renameSync(temporary,path);
+        const parent=openSync(root.directory,constants.O_RDONLY);try{fsyncSync(parent);}finally{closeSync(parent);}
+        const previous=current;current=retain(next);uncertain=false;if(previous!==root)closers.get(previous)();
+        return next;
+      }catch(error){next.close();if(uncertain)throw Object.assign(new Error('native_incarnation_uncertain',{cause:error}),{code:'native_incarnation_uncertain'});throw error;}
+      }finally{replacing=false;}
+    },
+    close(){if(stopped)return;stopped=true;try{if(current!==root)closers.get(current)();}finally{closeRoot();}}
+  };
+}

package/src/native-lock.mjs

@@ -0,0 +1,17 @@
+import { DatabaseSync } from 'node:sqlite';
+import { openSync, closeSync, lstatSync, constants } from 'node:fs';
+import { join } from 'node:path';
+import { privateDirectory } from './config.mjs';
+
+/** Cross-location/process ownership, released by the OS on crash. No stale reset. */
+export async function withNativeLock(directory, name, action) {
+  if (!['host-anchor','setup'].includes(name)) throw new Error('native_lock_invalid');
+  const path=join(privateDirectory(directory),`v2-${name}-owner.sqlite`);
+  try { const fd=openSync(path,constants.O_CREAT|constants.O_EXCL|constants.O_WRONLY|constants.O_NOFOLLOW,0o600);closeSync(fd); }
+  catch(error){if(error.code!=='EEXIST')throw error;}
+  const stat=lstatSync(path);
+  if(!stat.isFile()||stat.isSymbolicLink()||stat.mode&0o077||process.getuid&&stat.uid!==process.getuid())throw new Error('native_lock_invalid');
+  let db;
+  try{db=new DatabaseSync(path);db.exec('PRAGMA busy_timeout=0; BEGIN EXCLUSIVE; CREATE TABLE IF NOT EXISTS owner(id INTEGER)');return await action();}
+  finally{db?.close();}
+}

package/src/native-metadata.mjs

@@ -0,0 +1,15 @@
+import { projectMetadata } from './project-metadata.mjs';
+const label = (value, max = 256) => typeof value === 'string' && value.trim() && [...value].length <= max
+  && value.isWellFormed() && !/[\x00-\x1f\x7f-\x9f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/u.test(value) ? value.trim() : null;
+export function nativeMetadata(info, config = {}, env = process.env) {
+  const project = projectMetadata(config, env, info.location.directory);
+  const provider = label(info.model?.providerID, 128), id = label(info.model?.id);
+  let model = provider && id ? { provider, id, source: 'observed' } : { provider: null, id: null, source: 'unknown' };
+  if (model.source === 'unknown') {
+    const fallback = label(env.OPENCODE_MANAGED_MODEL, 385), slash = fallback?.indexOf('/') ?? -1;
+    const configuredProvider = slash > 0 ? label(fallback.slice(0, slash), 128) : null;
+    const configuredID = slash > 0 ? label(fallback.slice(slash + 1)) : null;
+    if (configuredProvider && configuredID) model = { provider: configuredProvider, id: configuredID, source: 'configured' };
+  }
+  return { name: label(config.name, 128) ?? 'OpenCode', project, model };
+}