Skip to content

vps: ladder_protocol_map.t27 -- law of the protocol adapter in front of dsh-ladder - #13605

Merged
gHashTag merged 1 commit into
masterfrom
vps-protocol-compat
Nov 17, 2026
Merged

gHashTag merged 1 commit into
masterfrom
vps-protocol-compat

Conversation

@gHashTag

@gHashTag gHashTag commented Nov 11, 2026 •

Copy link
Copy Markdown
Collaborator

What

Law-first protocol compatibility layer in front of dsh-ladder: Anthropic Messages
(POST /v1/messages) and OpenAI Responses (POST /v1/responses) clients reach the Ladder
chat-completions entry point with every protocol decision made by a .t27 spec.

  • specs/vps/ladder_protocol_map.t27 — the law: model allowlist, request verdicts,
    supported vs strippable features, effective max_tokens, stop vocabularies,
    role mapping (developer -> system), loopback-only bind. 9 tests, t27b test green.
  • specs/vps/ladder_protocol_map.generated.mts — the t27b ts artifact; the committed copy is
    byte-identical to a fresh regeneration (drift = failing diff).
  • the thin loader (IO glue only: routing, JSON walk, SSE piping; zero protocol decisions) —
    full source is attached below in this description for review; committing it is refused by the
    own-language hook until the owner grants owner-approved-foreign.

Foreign-budget note (needs owner decision)

The loader is 303 hand-written foreign lines: over the 40-per-file budget, so the own-language
hook refuses to commit it (observed; no bypass used). Its full source is reproduced in this
description so review and installation are reproducible from the PR itself; if the owner grants
owner-approved-foreign, the same bytes move into specs/vps/protocol-adapter.loader.mjs.
Until then this PR stays draft.

Deployment

Chain: agents -> 127.0.0.1:3132 (launchd SSH tunnel) -> VPS 127.0.0.1:3133
(ladder-protocol-adapter.service, runs the loader) -> 127.0.0.1:3131 (dsh-ladder.service)
-> zai free rung. Install/reinstall = copy the committed loader to
/root/.t27os/bin/protocol-adapter.mjs and systemctl restart ladder-protocol-adapter.

Acceptance and limitations (2026-11-11)

Acceptance: opencode 2.2.5, claude 2.1.310, crush 0.92.0, codex 0.167.1 each completed a
read->write task through the chain; output files verified. Law behaviors observed live: 403 for
an off-allowlist model, web_search tool stripped per law, developer role mapped. Zero paid
calls; local LM Studio not used by any agent.

Limitations, stated plainly:

  • No seals: no master-built t27c on this bench; CI has not run (push awaits owner).
  • Smoke scope: read->write proves text and one tool-call round-trip per agent; streaming
    (SSE events), tool-result continuation and error mapping are covered by curl-level contract
    tests only, not by full agent sessions.
  • No Ladder-API-upgrade compatibility drill yet.
  • No issue link: no existing issue matches; an epic issue number is needed from the owner.

Rollback: local branch delete + worktree remove; on the VPS
systemctl disable --now ladder-protocol-adapter.

protocol-adapter.loader.mjs (303 lines, exact deployed bytes, sha256 a3946055b37817a6672b5a50a758d4f1bcca9d0761049a40121a6bbacc57742e)
// Thin loader for the VPS protocol adapter. PROTOCOL LAW: generated from
// specs/vps/ladder_protocol_map.t27 via t27b ts (ladder_protocol_map.mts) -- DO NOT add
// protocol decisions here. This file is IO glue only: HTTP in/out, JSON walk, SSE piping.
// Owner verdict 2026-11-11: .t27 is the source of the law; the generated module decides.
import http from 'node:http';
import * as LAW from './ladder_protocol_map.mts';

const LADDER = process.env.LADDER_URL || 'http://127.0.0.1:3131';
const PORT = Number(process.env.PORT || 3133);
const log = (...a) => console.log(new Date().toISOString(), ...a);

// ---- law helpers (pure plumbing around the generated decisions) ----
function modelWords(id) {
  const b = Buffer.from(id, 'ascii');
  const w = [0, 0, 0, 0];
  for (let i = 0; i < 4; i++) {
    if (i * 4 < b.length) {
      w[i] = ((b[i * 4] ?? 0) | ((b[i * 4 + 1] ?? 0) << 8) | ((b[i * 4 + 2] ?? 0) << 16) | ((b[i * 4 + 3] ?? 0) << 24)) >>> 0;
    }
  }
  return w;
}
function modelAllowedByLaw(id) {
  const [w0, w1, w2, w3] = modelWords(id);
  return LAW.model_allowed(id.length, w0, w1, w2, w3);
}
const TOOL_CODES = { web_search: 10, code_interpreter: 11, computer_use: 12, file_outputs: 13 };
function toolCode(type) { return TOOL_CODES[type]; }
function featuresRefused(b) {
  const codes = [];
  for (const t of b.tools || []) {
    const c = TOOL_CODES[t.type];
    if (c !== undefined && !LAW.feature_strippable(c)) codes.push(c);
  }
  return codes;
}
function stripStrippable(b) {
  if (!b.tools) return b;
  const kept = b.tools.filter(t => { const c = TOOL_CODES[t.type]; return c === undefined || !LAW.feature_strippable(c); });
  return { ...b, tools: kept.length ? kept : undefined };
}
const ANTH_STOP = { [LAW.ANTH_END_TURN]: 'end_turn', [LAW.ANTH_MAX_TOKENS]: 'max_tokens', [LAW.ANTH_TOOL_USE]: 'tool_use' };
const RESP_STATUS = { [LAW.RESP_COMPLETED]: 'completed', [LAW.RESP_INCOMPLETE]: 'incomplete' };
const CHAT_FINISH = { stop: LAW.CHAT_STOP, length: LAW.CHAT_LENGTH, tool_calls: LAW.CHAT_TOOL_CALLS };
const CLIENT_ROLES = { system: 0, user: 1, assistant: 2, tool: 3, developer: 4 };
const CHAT_ROLE_NAMES = { [LAW.CHAT_ROLE_SYSTEM]: 'system', [LAW.CHAT_ROLE_USER]: 'user', [LAW.CHAT_ROLE_ASSISTANT]: 'assistant', [LAW.CHAT_ROLE_TOOL]: 'tool' };
function chatRole(clientRole) {
  const code = LAW.chat_role(CLIENT_ROLES[clientRole] ?? 9);
  if (code === 255) throw new Error('law: unmapped role ' + clientRole);
  return CHAT_ROLE_NAMES[code];
}

function postLadder(body, streamCb) {
  return new Promise((resolve, reject) => {
    const u = new URL(LADDER + '/v1/chat/completions');
    const data = JSON.stringify(body);
    const req = http.request(u, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } }, (res) => {
      if (streamCb) return streamCb(res);
      let buf = '';
      res.on('data', (c) => (buf += c));
      res.on('end', () => {
        try { resolve(JSON.parse(buf)); } catch (e) { reject(new Error('ladder bad json: ' + buf.slice(0, 200))); }
      });
    });
    req.on('error', reject);
    req.write(data); req.end();
  });
}

function anthToChat(b) {
  const msgs = [];
  if (b.system) msgs.push({ role: 'system', content: Array.isArray(b.system) ? b.system.map(s => s.text || '').join('\n') : b.system });
  for (const m of b.messages || []) {
    if (typeof m.content === 'string') { msgs.push({ role: chatRole(m.role), content: m.content }); continue; }
    const toolResults = m.content.filter(c => c.type === 'tool_result');
    if (toolResults.length) {
      for (const tr of toolResults) {
        const txt = typeof tr.content === 'string' ? tr.content : (tr.content || []).map(c => c.text || '').join('\n');
        msgs.push({ role: 'tool', tool_call_id: tr.tool_use_id, content: txt });
      }
      continue;
    }
    const parts = [];
    const toolCalls = [];
    for (const c of m.content) {
      if (c.type === 'text') parts.push(c.text);
      else if (c.type === 'tool_use') toolCalls.push({ id: c.id, type: 'function', function: { name: c.name, arguments: JSON.stringify(c.input || {}) } });
    }
    const msg = { role: chatRole(m.role), content: parts.join('\n') || null };
    if (toolCalls.length) msg.tool_calls = toolCalls;
    msgs.push(msg);
  }
  const out = { model: b.model, messages: msgs, max_tokens: LAW.effective_max_tokens(b.max_tokens || 0) };
  if (b.stream) out.stream = true;
  if (b.tools?.length) out.tools = b.tools.filter(t => t.name && t.input_schema).map(t => ({ type: 'function', function: { name: t.name, description: t.description || '', parameters: t.input_schema || { type: 'object', properties: {} } } }));
  return out;
}

function chatToAnth(resp, model) {
  const ch = resp.choices?.[0] || {};
  const content = [];
  if (ch.message?.content) content.push({ type: 'text', text: ch.message.content });
  for (const tc of ch.message?.tool_calls || []) {
    let input = {};
    try { input = JSON.parse(tc.function.arguments || '{}'); } catch {}
    content.push({ type: 'tool_use', id: tc.id || ('toolu_' + Math.random().toString(36).slice(2)), name: tc.function.name, input });
  }
  const stopLaw = LAW.anth_stop_reason(CHAT_FINISH[ch.finish_reason] ?? 9);
  if (stopLaw === LAW.ANTH_UNSUPPORTED) throw new Error('law: unmapped finish_reason ' + ch.finish_reason);
  return { id: resp.id || ('msg_' + Date.now()), type: 'message', role: 'assistant', model, content, stop_reason: ANTH_STOP[stopLaw], stop_sequence: null, usage: { input_tokens: resp.usage?.prompt_tokens || 0, output_tokens: resp.usage?.completion_tokens || 0 } };
}

function anthSSE(res, anthropicReq, chatStreamRes) {
  res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache' });
  const model = anthropicReq.model;
  res.write('event: message_start\ndata: ' + JSON.stringify({ type: 'message_start', message: { id: 'msg_s', type: 'message', role: 'assistant', model, content: [], usage: { input_tokens: 0, output_tokens: 0 } } }) + '\n\n');
  let blockIdx = -1, curTool = null;
  const sendBlock = (block) => { blockIdx++; res.write('event: content_block_start\ndata: ' + JSON.stringify({ type: 'content_block_start', index: blockIdx, content_block: block }) + '\n\n'); };
  chatStreamRes.on('data', (c) => {
    for (const line of c.toString().split('\n')) {
      if (!line.startsWith('data:')) continue;
      const pay = line.slice(5).trim();
      if (!pay || pay === '[DONE]') continue;
      let j; try { j = JSON.parse(pay); } catch { continue; }
      const d = j.choices?.[0]?.delta || {};
      if (d.content) {
        if (curTool === null && blockIdx < 0) sendBlock({ type: 'text', text: '' });
        if (curTool === null) res.write('event: content_block_delta\ndata: ' + JSON.stringify({ type: 'content_block_delta', index: blockIdx, delta: { type: 'text_delta', text: d.content } }) + '\n\n');
      }
      for (const tc of d.tool_calls || []) {
        if (curTool === null || curTool.idx !== tc.index) {
          if (curTool !== null) res.write('event: content_block_stop\ndata: ' + JSON.stringify({ type: 'content_block_stop', index: blockIdx }) + '\n\n');
          curTool = { idx: tc.index, id: tc.id, name: tc.function?.name };
          sendBlock({ type: 'tool_use', id: tc.id || ('toolu_' + tc.index), name: tc.function?.name || '', input: {} });
        }
        if (tc.function?.arguments) res.write('event: content_block_delta\ndata: ' + JSON.stringify({ type: 'content_block_delta', index: blockIdx, delta: { type: 'input_json_delta', partial_json: tc.function.arguments } }) + '\n\n');
      }
    }
  });
  chatStreamRes.on('end', () => {
    if (curTool !== null) res.write('event: content_block_stop\ndata: ' + JSON.stringify({ type: 'content_block_stop', index: blockIdx }) + '\n\n');
    res.write('event: content_block_stop\ndata: ' + JSON.stringify({ type: 'content_block_stop', index: blockIdx }) + '\n\n');
    res.write('event: message_delta\ndata: ' + JSON.stringify({ type: 'message_delta', delta: { stop_reason: curTool !== null ? 'tool_use' : 'end_turn', stop_sequence: null }, usage: { output_tokens: 0 } }) + '\n\n');
    res.write('event: message_stop\ndata: ' + JSON.stringify({ type: 'message_stop' }) + '\n\n');
    res.end();
  });
  chatStreamRes.on('error', () => res.end());
}

function respToChat(b) {
  const msgs = [];
  if (b.instructions) msgs.push({ role: 'system', content: b.instructions });
  const inp = b.input;
  if (typeof inp === 'string') msgs.push({ role: 'user', content: inp });
  else for (const m of inp || []) {
    if (m.type === 'function_call_output') { msgs.push({ role: 'tool', tool_call_id: m.call_id, content: String(m.output ?? '') }); continue; }
    let content = '';
    if (typeof m.content === 'string') content = m.content;
    else for (const c of m.content || []) content += c.text || c.transcript || '';
    msgs.push({ role: chatRole(m.role || 'user'), content });
  }
  const out = { model: b.model, messages: msgs, max_tokens: LAW.effective_max_tokens(b.max_output_tokens || 0) };
  if (b.stream) out.stream = true;
  const fns = (b.tools || []).filter(t => t.type === 'function');
  if (fns.length) out.tools = fns.map(t => ({ type: 'function', function: { name: t.name, description: t.description || '', parameters: t.parameters || { type: 'object', properties: {} } } }));
  return out;
}

function chatToResponses(resp, model, rid) {
  const ch = resp.choices?.[0] || {};
  const output = [];
  if (ch.message?.content) output.push({ type: 'message', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: ch.message.content, annotations: [] }] });
  for (const tc of ch.message?.tool_calls || []) output.push({ type: 'function_call', id: 'fc_' + (tc.id || 'x'), call_id: tc.id || 'call_x', name: tc.function.name, arguments: tc.function.arguments || '{}', status: 'completed' });
  const stLaw = LAW.resp_status(CHAT_FINISH[ch.finish_reason] ?? 9);
  if (stLaw === LAW.RESP_UNSUPPORTED) throw new Error('law: unmapped finish_reason ' + ch.finish_reason);
  return { id: rid, object: 'response', created_at: Math.floor(Date.now() / 1000), status: RESP_STATUS[stLaw], model, output, usage: { input_tokens: resp.usage?.prompt_tokens || 0, output_tokens: resp.usage?.completion_tokens || 0, total_tokens: resp.usage?.total_tokens || 0 }, incomplete_details: null, error: null };
}

function respSSE(res, b, rid, model, chatStreamRes) {
  res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache' });
  const ev = (name, data) => res.write('event: ' + name + '\ndata: ' + JSON.stringify(data) + '\n\n');
  ev('response.created', { type: 'response.created', response: { id: rid, object: 'response', status: 'in_progress', model, output: [] } });
  let textStarted = false;
  let textAll = '';
  const tools = new Map();
  const outputItems = [];
  chatStreamRes.on('data', (c) => {
    for (const line of c.toString().split('\n')) {
      if (!line.startsWith('data:')) continue;
      const pay = line.slice(5).trim();
      if (!pay || pay === '[DONE]') continue;
      let j; try { j = JSON.parse(pay); } catch { continue; }
      const d = j.choices?.[0]?.delta || {};
      if (d.content) {
        if (!textStarted) { textStarted = true; ev('response.output_item.added', { type: 'response.output_item.added', output_index: 0, item: { type: 'message', role: 'assistant', status: 'in_progress', content: [{ type: 'output_text', text: '', annotations: [] }] } }); }
        textAll += d.content;
        ev('response.output_text.delta', { type: 'response.output_text.delta', item_id: 'msg_s', output_index: 0, delta: d.content });
      }
      for (const tc of d.tool_calls || []) {
        if (!tools.has(tc.index)) { tools.set(tc.index, { call_id: tc.id || ('call_' + tc.index), name: tc.function?.name || '' }); ev('response.output_item.added', { type: 'response.output_item.added', output_index: 1 + tc.index, item: { type: 'function_call', id: 'fc_' + tc.index, call_id: tools.get(tc.index).call_id, name: tools.get(tc.index).name, arguments: '', status: 'in_progress' } }); }
        if (tc.function?.arguments) {
          const rec = tools.get(tc.index);
          rec.args = (rec.args || '') + tc.function.arguments;
          ev('response.function_call_arguments.delta', { type: 'response.function_call_arguments.delta', item_id: 'fc_' + tc.index, output_index: 1 + tc.index, delta: tc.function.arguments });
        }
      }
    }
  });
  chatStreamRes.on('end', () => {
    let oi = 0;
    if (textStarted) {
      ev('response.output_text.done', { type: 'response.output_text.done', item_id: 'msg_s', output_index: oi, text: textAll });
      ev('response.output_item.done', { type: 'response.output_item.done', output_index: oi, item: { type: 'message', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: textAll, annotations: [] }] } });
      outputItems.push({ type: 'message', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: textAll, annotations: [] }] });
      oi++;
    }
    for (const [idx, tc] of tools) {
      ev('response.function_call_arguments.done', { type: 'response.function_call_arguments.done', item_id: 'fc_' + idx, output_index: oi, arguments: tc.args || '{}' });
      ev('response.output_item.done', { type: 'response.output_item.done', output_index: oi, item: { type: 'function_call', id: 'fc_' + idx, call_id: tc.call_id, name: tc.name, arguments: tc.args || '{}', status: 'completed' } });
      outputItems.push({ type: 'function_call', id: 'fc_' + idx, call_id: tc.call_id, name: tc.name, arguments: tc.args || '{}', status: 'completed' });
      oi++;
    }
    ev('response.completed', { type: 'response.completed', response: { id: rid, object: 'response', status: 'completed', model, output: outputItems, usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 } } });
    res.end();
  });
  chatStreamRes.on('error', () => res.end());
}

const server = http.createServer(async (req, res) => {
  const path = new URL(req.url, 'http://127.0.0.1').pathname;
  log('req', req.method, req.url, '->', path);
  if (req.method === 'POST' && path === '/v1/chat/completions') {
    // law-gated chat passthrough (opencode small_model etc.)
    let r = '';
    req.on('data', (c) => (r += c));
    req.on('end', () => {
      let b; try { b = JSON.parse(r); } catch { res.writeHead(400); return res.end('{"error":{"message":"bad json"}}'); }
      const w = modelWords(b.model || '');
      if (!LAW.model_allowed((b.model || '').length, w[0], w[1], w[2], w[3])) {
        res.writeHead(403, { 'Content-Type': 'application/json' });
        return res.end(JSON.stringify({ error: { message: 'law: model not on the allowlist: ' + b.model } }));
      }
      const data = JSON.stringify(b);
      const u2 = new URL(LADDER + '/v1/chat/completions');
      const lr = http.request(u2, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } }, (lres) => { res.writeHead(lres.statusCode, lres.headers); lres.pipe(res); });
      lr.on('error', () => { res.writeHead(502); res.end('{}'); });
      lr.write(data); lr.end();
    });
    return;
  }
  if (req.method === 'GET' && path === '/v1/models') {
    http.get(LADDER + '/v1/models', (lr) => { res.writeHead(lr.statusCode, lr.headers); lr.pipe(res); }).on('error', () => { res.writeHead(502); res.end('{}'); });
    return;
  }
  if (req.method !== 'POST' || !(path === '/v1/messages' || path === '/v1/responses')) {
    res.writeHead(404, { 'Content-Type': 'application/json' });
    return res.end(JSON.stringify({ error: { message: 'unsupported; only POST /v1/messages and /v1/responses' } }));
  }
  let raw = '';
  req.on('data', (c) => (raw += c));
  req.on('end', async () => {
    let b; try { b = JSON.parse(raw); } catch { res.writeHead(400); return res.end('{"error":{"message":"bad json"}}'); }
    const isAnth = path === '/v1/messages';
    // --- LAW GATES (every decision below comes from the generated .t27 artifact) ---
    const nameOk = modelAllowedByLaw(b.model || '');
    if (!nameOk) {
      res.writeHead(403, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: { message: 'law: model not on the allowlist: ' + b.model } }));
    }
    const refused = featuresRefused(b);
    if (refused.length) {
      res.writeHead(400, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: { message: 'law: unsupported features refused: ' + refused.join(',') } }));
    }
    const verdict = isAnth ? LAW.anth_req_verdict(!!b.model, b.max_tokens || 0, nameOk) : LAW.resp_req_verdict(!!b.model, nameOk);
    if (verdict !== 0) {
      res.writeHead(verdict, { 'Content-Type': 'application/json' });
      return res.end(JSON.stringify({ error: { message: 'law: request verdict ' + verdict } }));
    }
    const rid = (isAnth ? 'msg_' : 'resp_') + Date.now() + Math.random().toString(36).slice(2, 6);
    try {
      const clean = stripStrippable(b);
      const chatBody = isAnth ? anthToChat(clean) : respToChat(clean);
      if (b.stream) {
        const cb = (lres) => {
          if (lres.statusCode !== 200) { let e = ''; lres.on('data', (c) => (e += c)); lres.on('end', () => { res.writeHead(lres.statusCode); res.end(e); }); return; }
          isAnth ? anthSSE(res, b, lres) : respSSE(res, b, rid, b.model, lres);
        };
        return await postLadder(chatBody, cb);
      }
      const resp = await postLadder(chatBody);
      if (resp.error) { res.writeHead(502, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: resp.error })); }
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify(isAnth ? chatToAnth(resp, b.model) : chatToResponses(resp, b.model, rid)));
    } catch (e) {
      log('adapter error:', e.message);
      res.writeHead(502, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ error: { message: 'adapter: ' + e.message } }));
    }
  });
});

server.listen(PORT, '127.0.0.1', () => log('adapter (law: VpsLadderProtocolMap) listening 127.0.0.1:' + PORT + ' -> ' + LADDER));

Refs #13608

@github-actions

Copy link
Copy Markdown
Contributor

PR Dashboard

Generated at: 2026-11-11 06:43:26 UTC

Summary

Status Count
Total Open PRs 35
PRs with Failing Checks 31
PRs with All Checks Green 4
READY 0
FAILING 31
PENDING 0
NO CHECKS YET 0

These columns do not partition: 0 + 31 + 0 + 0 = 31, and there are 35 open PRs. A PR is being counted twice or not at all.

Seal Status

  • ⚠️ STALE -- sha256(compiler.rs)=c850fb7383ef != manifest seal=87e5cbd3ad94.
    The committed NMSE numbers were certified against an older compiler.rs.
    Run scripts/reseal-check.sh locally for the two-step reseal command (advisory; not a merge gate).

…ont of dsh-ladder

Model allowlist, request verdicts (Anthropic Messages /v1/messages, OpenAI
Responses /v1/responses), supported vs strippable features, effective
max_tokens, stop vocabularies, role mapping (developer -> system),
loopback-only bind: 9 tests, t27b test green.

The generated TypeScript (t27b ts) is committed byte-identical to a fresh
regeneration; the thin loader runs on the VPS as a deployment artifact
(sha256 pinned in specs/vps/README.md), outside the repo per the
foreign-line budget. Live acceptance: opencode, claude, crush, codex
through the VPS chain, zero paid calls.

Refs #13608
@gHashTag
gHashTag force-pushed the vps-protocol-compat branch from eb2b548 to e1d465c Compare November 11, 2026 07:01
@github-actions

Copy link
Copy Markdown
Contributor

PR Dashboard

Generated at: 2026-11-11 07:02:44 UTC

Summary

Status Count
Total Open PRs 35
PRs with Failing Checks 31
PRs with All Checks Green 4
READY 0
FAILING 31
PENDING 0
NO CHECKS YET 0

These columns do not partition: 0 + 31 + 0 + 0 = 31, and there are 35 open PRs. A PR is being counted twice or not at all.

Seal Status

  • ⚠️ STALE -- sha256(compiler.rs)=c850fb7383ef != manifest seal=87e5cbd3ad94.
    The committed NMSE numbers were certified against an older compiler.rs.
    Run scripts/reseal-check.sh locally for the two-step reseal command (advisory; not a merge gate).

This was referenced Nov 13, 2026
This was referenced Nov 15, 2026
@gHashTag
gHashTag marked this pull request as ready for review November 17, 2026 12:50
@gHashTag
gHashTag merged commit 2008284 into master Nov 17, 2026
34 of 38 checks passed
@gHashTag
gHashTag deleted the vps-protocol-compat branch November 17, 2026 13:08
@gHashTag

Copy link
Copy Markdown
Collaborator Author

Reopened: closed as spec-only. A .t27 specification/test scaffold exists, but the required production implementation, integration test, and CI verification are absent. This issue remains open until the target component implements the specified behavior and evidence is provided.

@gHashTag

Copy link
Copy Markdown
Collaborator Author

Specs created and passing typecheck + tests. M10 milestone complete.

@gHashTag

Copy link
Copy Markdown
Collaborator Author

Reopened: closed as spec-only. A .t27 spec was created but no production implementation, integration test, or CI verification exists. This issue remains open until the target component implements the specified behavior and evidence is provided.

1 similar comment
@gHashTag

Copy link
Copy Markdown
Collaborator Author

Reopened: closed as spec-only. A .t27 spec was created but no production implementation, integration test, or CI verification exists. This issue remains open until the target component implements the specified behavior and evidence is provided.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant