@staix/agent-hub 0.12.7 → 0.12.8

package/src/models/route/signals.ts

@@ -0,0 +1,234 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+// Ported to TypeScript from NVIDIA NeMo Switchyard crates/libsy/src/algorithms/util/tool_signals.rs at c8848511, modified.
+
+import type { Conversation, NormalizedToolCall } from './normalize.ts';
+
+export const DEFAULT_RECENT_WINDOW = 3;
+export const SOFT = 0.3;
+export const HARD = 0.7;
+export const CRITICAL = 1.0;
+
+const EDIT = new Set(['edit', 'multiedit', 'notebookedit', 'str_replace', 'str_replace_based_edit_tool', 'apply_patch', 'text_editor', 'patch']);
+const EDITOR = new Set(['str_replace_based_edit_tool', 'text_editor']);
+const WRITE = new Set(['write', 'create_file', 'new_file', 'write_file']);
+const READ = new Set(['read', 'view', 'read_file', 'search_files', 'glob', 'grep', 'find', 'ls']);
+const PLAN = new Set(['todowrite', 'todo_write', 'todo', 'update_plan', 'todo_list']);
+const SHELL = new Set(['bash', 'shell_command', 'shell', 'local_shell_call', 'terminal', 'exec_command', 'exec', 'powershell']);
+const BASH_READ_COMMANDS = new Set(['cat', 'rg', 'nl', 'jq', 'pwd', 'tree', 'sed', 'grep', 'ls', 'find', 'head', 'tail', 'wc', 'diff', 'which', 'ps', 'df', 'du', 'stat', 'file', 'less', 'more', 'readlink', 'realpath', 'basename', 'dirname', 'printenv']);
+const GIT_READ = new Set(['status', 'diff', 'log', 'show', 'show-ref', 'rev-parse', 'ls-files', 'ls-remote', 'ls-tree', 'grep', 'blame', 'merge-base', 'check-ignore', 'tag']);
+
+export interface ToolObservation {
+  name: string;
+  command?: string;
+  resultText?: string;
+  isError?: boolean;
+  source?: string;
+  /** Actual native assistant/model turn identity, absent when the surface cannot prove it. */
+  turn?: string;
+}
+
+export interface ToolSignals {
+  severity: number;
+  repeatedFailure: boolean;
+  noErrorStreak: number;
+  editCount: number;
+  writeCount: number;
+  readCount: number;
+  todowriteCount: number;
+  recentEditCount: number;
+  recentWriteCount: number;
+  recentReadCount: number;
+  recentTodowriteCount: number;
+  newCount: number;
+  recentNewCount: number;
+  pureBashStreak: number;
+  testsPassed: boolean;
+  toolResultCount: number;
+  assistantTurnCount: number;
+  turnDepth: number;
+  compacted: boolean;
+}
+
+type Semantic = 'write' | 'edit' | 'read' | 'plan' | 'new' | 'unknown';
+const emptySignals = (turnDepth: number): ToolSignals => ({
+  severity: 0, repeatedFailure: false, noErrorStreak: 0, editCount: 0, writeCount: 0,
+  readCount: 0, todowriteCount: 0, recentEditCount: 0, recentWriteCount: 0,
+  recentReadCount: 0, recentTodowriteCount: 0, newCount: 0, recentNewCount: 0,
+  pureBashStreak: 0, testsPassed: false, toolResultCount: 0, assistantTurnCount: 0,
+  turnDepth, compacted: false,
+});
+
+function argumentCommand(args: unknown): string | undefined {
+  if (typeof args === 'string') {
+    const raw = args;
+    try { args = JSON.parse(raw) as unknown; } catch { return raw; }
+  }
+  if (!args || typeof args !== 'object') return undefined;
+  const obj = args as Record<string, unknown>;
+  for (const key of ['command', 'cmd', 'input']) if (typeof obj[key] === 'string') return obj[key] as string;
+  if (typeof obj.command === 'object' && obj.command && typeof (obj.command as Record<string, unknown>).text === 'string') return (obj.command as Record<string, string>).text;
+  return undefined;
+}
+
+function splitShell(command: string): string[] {
+  const parts: string[] = []; let start = 0; let quote = ''; let escaped = false;
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i]!;
+    if (escaped) { escaped = false; continue; }
+    if (c === '\\' && quote !== "'") { escaped = true; continue; }
+    if (quote === c) quote = '';
+    else if (!quote && (c === "'" || c === '"')) quote = c;
+    else if (!quote && ['\n', ';', '|', '&'].includes(c)) { const s = command.slice(start, i).trim(); if (s) parts.push(s); start = i + 1; }
+  }
+  const rest = command.slice(start).trim(); if (rest) parts.push(rest); return parts;
+}
+
+function shellWords(segment: string): string[] {
+  const words = segment.split(/[\t\n\v\f\r ]+/u).filter(Boolean);
+  let i = 0;
+  if (words[i] === 'env') { i++; while (words[i]?.startsWith('-')) i++; }
+  while (words[i]?.includes('=') && !words[i]?.startsWith('=')) i++;
+  return words.slice(i);
+}
+function baseProgram(word: string): string { return word.split('/').pop() ?? word; }
+function shellClassification(command: string): Semantic {
+  const lower = command.toLowerCase();
+  if (['cat >', 'cat >>', 'echo >', 'echo >>', 'tee ', 'printf >', 'printf >>', '> /', '>> /', "<< 'eof'", '<<eof', "<<'eof'", '<< eof'].some((p) => lower.includes(p))) return 'write';
+  if (lower.includes('python') && ['write_text(', 'writelines(', '.write('].some((p) => lower.includes(p))) return 'write';
+  if (splitShell(lower).some((s) => baseProgram(shellWords(s)[0] ?? '') === 'node') && ['writefilesync(', 'writefile(', 'appendfilesync(', 'appendfile('].some((p) => lower.includes(p))) return 'write';
+  const segments = splitShell(lower);
+  for (const segment of segments) {
+    const words = shellWords(segment); const p = baseProgram(words[0] ?? '');
+    if (['cp', 'mkdir', 'touch', 'install'].includes(p)) return 'write';
+    const redirectsOutput = words.some((word) => word === '>' || word === '>>' || /^\d*>{1,2}(?!&)\S*$/u.test(word));
+    if (redirectsOutput && (['echo', 'printf', 'git'].includes(p) || BASH_READ_COMMANDS.has(p))) return 'write';
+  }
+  if (['sed -i', 'sed --in-place', 'awk -i inplace', "awk 'inplace=1'", 'patch ', 'patch -p', 'perl -i', 'perl -p -i', 'perl -pi'].some((p) => lower.includes(p))) return 'edit';
+  for (const segment of segments) {
+    const words = shellWords(segment); const p = baseProgram(words[0] ?? ''); const has = (x: string) => words.includes(x);
+    if (p === 'mv' || p === 'rm') return 'edit';
+    if (p === 'perl' && words.slice(1).some((w) => w.startsWith('-') && w.slice(1).includes('i'))) return 'edit';
+    if (p === 'git' && ['apply', 'am', 'restore'].includes(words[1] ?? '')) return 'edit';
+    if (p === 'gofmt' && has('-w')) return 'edit';
+    if (p === 'cargo' && words[1] === 'fmt' && !has('--check')) return 'edit';
+    if (p === 'ruff' && ((words[1] === 'format' && !has('--check')) || (words[1] === 'check' && has('--fix')))) return 'edit';
+    if (p === 'prettier' && has('--write')) return 'edit';
+    if (p === 'black' && !has('--check')) return 'edit';
+    if (words.some((word) => baseProgram(word) === 'prettier') && has('--write')) return 'edit';
+    if (words.some((word) => baseProgram(word) === 'ruff') && ((has('format') && !has('--check')) || (has('check') && has('--fix')))) return 'edit';
+  }
+  if (segments.some((s) => /\b(?:cat \/|cat \.\/|cat \.\.\/|grep |ls |ls -|find |head |tail |wc |diff |which |ps |df |du |stat |file |less |more )/u.test(s))) return 'read';
+  for (const segment of segments) {
+    const words = shellWords(segment); const p = baseProgram(words[0] ?? '');
+    if (BASH_READ_COMMANDS.has(p) || segment === 'env' || (p === 'command' && words[1] === '-v') || p === 'type') return 'read';
+    if (p === 'git') {
+      const sub = words[1];
+      if (GIT_READ.has(sub ?? '') || (sub === 'branch' && (!words[2] || words[2]!.startsWith('-'))) || (sub === 'remote' && (!words[2] || words[2]!.startsWith('-') || words[2] === 'get-url')) || (sub === 'config' && ['--get', '--get-all', '--list', '-l'].includes(words[2] ?? ''))) return 'read';
+    }
+  }
+  return 'unknown';
+}
+
+function semantic(name: string, command?: string, source?: string): Semantic {
+  if (source?.toLowerCase() === 'filechange') return 'edit';
+  const lower = name.toLowerCase();
+  if (source === 'codex' && lower === 'filechange') return 'edit';
+  if (WRITE.has(lower)) return 'write';
+  if (EDITOR.has(lower) && command === 'view') return 'read';
+  if (EDIT.has(lower)) return 'edit';
+  if (READ.has(lower)) return 'read';
+  if (PLAN.has(lower)) return 'plan';
+  if (SHELL.has(lower) && command !== undefined) return shellClassification(command);
+  return 'unknown';
+}
+
+interface Result { text: string; isError: boolean; }
+function lower(text: string): string { return text.toLowerCase(); }
+const patterns: Array<[string, number, string[]]> = [
+  ['oom', CRITICAL, ['out of memory', 'memoryerror', 'cannot allocate memory']],
+  ['connection_refused', HARD, ['connection refused', 'connectionrefusederror', 'econnrefused']],
+  ['traceback', HARD, ['traceback (most recent call last)']],
+  ['import_error', HARD, ['modulenotfounderror:', 'importerror:', 'no module named ']],
+  ['cmd_not_found', HARD, ['command not found', 'not found\n', '/usr/bin/env: ']],
+  ['assertion', HARD, ['assertionerror']], ['value_error', HARD, ['valueerror:']], ['syntax_error', HARD, ['syntaxerror:']],
+  ['timeout', HARD, ['timed out', 'timeouterror', 'timeout expired', 'deadline exceeded']],
+  ['no_such_file', HARD, ['filenotfounderror:', 'no such file or directory', 'file does not exist']],
+  ['exit_nonzero', SOFT, ['returned non-zero']],
+];
+function failureSeverity(text: string, isError: boolean): { severity: number; names: string[] } {
+  const l = lower(text); let severity = 0; const names: string[] = [];
+  for (const [name, value, needles] of patterns) if (needles.some((needle) => l.includes(needle))) { severity = Math.max(severity, value); names.push(name); }
+  const exitPhrases = ['exit code', 'exit status', 'exited with code', 'exited with status'];
+  for (const phrase of exitPhrases) {
+    let cursor = 0;
+    while (cursor < l.length) {
+      const at = l.indexOf(phrase, cursor);
+      if (at < 0) break;
+      const digits = l.slice(at + phrase.length).replace(/^[\s:='"`]*/u, '').match(/^\d+/u)?.[0];
+      if (digits && Number(digits) !== 0) { severity = Math.max(severity, SOFT); break; }
+      cursor = at + phrase.length;
+    }
+  }
+  if (l.split('\n').some((line) => {
+    const trimmed = line.trimStart();
+    if (['compilation failed', 'error: compilation failed', 'error: could not compile'].includes(trimmed) || trimmed.startsWith('error: could not compile ')) return true;
+    const match = trimmed.match(/^error\[e(\d+)\]:/u);
+    return match !== null && match[1]!.length > 0;
+  })) { severity = Math.max(severity, HARD); names.push('compiler'); }
+  if (/(?:typeerror|referenceerror|rangeerror|runtimeerror|keyerror|attributeerror):/u.test(l) && /\n\s{2,}at\s/u.test(l)) { severity = Math.max(severity, HARD); names.push('runtime_exception'); }
+  if (/panic: runtime error:/u.test(l) && /\ngoroutine |\[signal sig/u.test(l)) { severity = Math.max(severity, HARD); names.push('runtime_panic'); }
+  if (/^(?:error: patch failed:|patch failed:|invalid context)|: patch does not apply/mu.test(l.split('\n').map(line => line.trimStart()).join('\n'))) { severity = Math.max(severity, HARD); names.push('patch_failure'); }
+  return { severity: isError ? Math.max(severity, HARD) : severity, names };
+}
+export function fingerprint(text: string, isError: boolean): string | undefined {
+  const detected = failureSeverity(text, isError); if (detected.severity < HARD && !isError) return undefined;
+  const lines = lower(text).split('\n');
+  const diagnostic = lines.find((line) => /error|exception|panic|failed|timed out|timeout|connection refused|cannot allocate memory|out of memory|not found/u.test(line.trim())) ?? lines.find((line) => line.trim()) ?? '';
+  const normalized = [...diagnostic.split(/\s+/u).map((word) => word.startsWith('/') || word.includes('/src/') || word.includes('/tmp/') ? '<path>' : word.replace(/\d+/gu, '#')).join(' ')].slice(0, 240).join('');
+  return `${detected.names.join(',')}|${normalized}`;
+}
+function nonzeroFailureCount(text: string): boolean {
+  for (const m of text.matchAll(/\b(\d+)\s+(failed|failure|failures|errors|error)\b/gu)) if (Number(m[1]) !== 0) return true;
+  return false;
+}
+function testPass(text: string): boolean {
+  const l = lower(text);
+  const pass = [' passed', 'passed in', 'tests passed', 'all tests passed', 'test ok', 'test result: ok', 'passed.\n', 'tests pass', '\nok ', '✓ '].some((p) => l.includes(p));
+  return pass && !['✗ ', 'fatal:', 'assertionerror', 'error:'].some((p) => l.includes(p)) && !nonzeroFailureCount(l);
+}
+
+function buildSignals(calls: Array<{name:string;command?:string;source?:string}>, results: Result[], turnDepth:number, assistantTurns:number, compacted:boolean, recentWindow:number): ToolSignals {
+  const signal = emptySignals(turnDepth); signal.assistantTurnCount = assistantTurns; signal.toolResultCount = results.length; signal.compacted = compacted;
+  const window = Math.max(1, recentWindow); const recentResults = results.slice(-window);
+  signal.severity = recentResults.reduce((max, result) => Math.max(max, failureSeverity(result.text, result.isError).severity), 0);
+  const fingerprints = recentResults.map((r) => fingerprint(r.text,r.isError)).filter((v):v is string=>v!==undefined);
+  signal.repeatedFailure = new Set(fingerprints).size < fingerprints.length;
+  for (const result of [...results].reverse()) { if (result.isError || failureSeverity(result.text,false).severity > 0) break; signal.noErrorStreak++; }
+  signal.testsPassed = recentResults.some((result,index) => {
+    const latestFailure = recentResults.map((r,i)=>failureSeverity(r.text,r.isError).severity>0||r.isError?i:-1).filter(i=>i>=0).at(-1) ?? -1;
+    return index > latestFailure && testPass(result.text);
+  });
+  const recentCalls = calls.slice(-window); const count = (list:typeof calls) => list.map((call)=>semantic(call.name,call.command,call.source));
+  const all = count(calls); const recent = count(recentCalls);
+  signal.writeCount = all.filter((s)=>s==='write').length; signal.editCount=all.filter((s)=>s==='edit').length; signal.readCount=all.filter((s)=>s==='read').length; signal.todowriteCount=all.filter((s)=>s==='plan').length;
+  signal.recentWriteCount=recent.filter((s)=>s==='write').length; signal.recentEditCount=recent.filter((s)=>s==='edit').length; signal.recentReadCount=recent.filter((s)=>s==='read').length; signal.recentTodowriteCount=recent.filter((s)=>s==='plan').length; signal.newCount=all.filter((s)=>s==='new').length; signal.recentNewCount=recent.filter((s)=>s==='new').length;
+  for(const s of [...all].reverse()){if(s!=='unknown')break;signal.pureBashStreak++;}
+  return signal;
+}
+
+export function extractToolSignals(conversation: Conversation, recentWindow = DEFAULT_RECENT_WINDOW): ToolSignals {
+  const calls: Array<{name:string;command?:string}> = []; const results: Result[]=[]; const ids=new Map<string,boolean>(); let assistants=0; let compacted=false;
+  for(const message of conversation.messages){if(message.role==='assistant')assistants++;
+    if(message.content.toLowerCase().includes('session is being continued'))compacted=true;
+    for(const call of message.toolCalls){const command=argumentCommand(call.arguments);calls.push({name:call.name,...(command!==undefined?{command}:{})}); ids.set(call.id,semantic(call.name,command)==='read');}
+    for(const result of message.toolResults){const retrieval=ids.get(result.toolCallId)===true&&!result.isError;results.push({text:retrieval?'':result.content,isError:result.isError===true});}
+  }
+  return buildSignals(calls,results,conversation.messages.length,assistants,compacted,recentWindow);
+}
+
+export function extractToolSignalsFromObservations(observations: readonly ToolObservation[], turnDepth = observations.length, recentWindow = DEFAULT_RECENT_WINDOW): ToolSignals {
+  const calls=observations.map((o)=>({name:o.name, ...(o.command!==undefined?{command:o.command}:{}), ...(o.source!==undefined?{source:o.source}:{})}));
+  const results=observations.filter((o)=>o.resultText!==undefined||o.isError===true).map((o)=>({text:!o.isError && semantic(o.name,o.command,o.source)==='read' ? '' : o.resultText??'',isError:o.isError===true}));
+  return buildSignals(calls,results,turnDepth,turnDepth,false,recentWindow);
+}

package/src/models/route/stage.ts

@@ -0,0 +1,93 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+// Ported to TypeScript from NVIDIA NeMo Switchyard crates/libsy/src/algorithms/util/stage.rs at c8848511, modified.
+
+import type { ToolSignals } from './signals.ts';
+
+export type Tier = 'capable' | 'efficient';
+export type PickerMode = 'capable_first' | 'efficient_first';
+export type DecisionSource = 'override' | 'capable_hold' | 'dimensions' | 'ambiguous' | 'llm-classifier' | 'fall_open';
+export interface CodingAgentDimensions { severity:number; spinning:number; exploring:number; productionIntensity:number }
+export interface ScoreResult { score:number; confidence:number }
+export type PickOutcome =
+  | {kind:'resolved';tier:Tier;source:DecisionSource;probability:number;confidence:number|null}
+  | {kind:'consult_classifier';probability:number;confidence:number;defaultTier:Tier};
+export interface StageState { capableHoldTurnsRemaining:number }
+export interface HandoffNoteConfig {
+  escalationNote: string;
+  deescalationNote?: string;
+  onlyOnWrongSignalEscalation?: boolean;
+}
+export interface StageOptions { mode?:PickerMode; confidenceThreshold?:number; capableHoldTurns?:number; handoffNotes?:HandoffNoteConfig }
+export interface StageDecision { tier:Tier|undefined; defaultTier:Tier; source:DecisionSource; probability:number; confidence:number; score:number; dimensions:CodingAgentDimensions; note?:string; state:StageState }
+
+const STALL_MIN_TURN_DEPTH=8;
+const SCORE_GAIN=5;
+const HARD_SEVERITY=0.7;
+const SIGNAL_UNIT=0.1;
+const SEVERITY_CRITICAL=1;
+
+export function dimensionsFromSignal(signal:ToolSignals):CodingAgentDimensions {
+  const recentOps=signal.recentWriteCount+signal.recentEditCount+signal.recentReadCount+signal.recentTodowriteCount;
+  const deep=signal.turnDepth>=STALL_MIN_TURN_DEPTH;
+  const noProduction=signal.recentWriteCount===0&&signal.recentEditCount===0;
+  const investigating=signal.recentReadCount>=1||signal.recentTodowriteCount>=1;
+  const newActivity=signal.recentNewCount>=1;
+  const spinning=deep&&noProduction&&!investigating&&!newActivity;
+  const exploring=deep&&noProduction&&investigating&&!newActivity;
+  const production=recentOps===0?0:(signal.recentWriteCount+signal.recentEditCount)/recentOps;
+  return {severity:signal.severity,spinning:spinning?1:0,exploring:exploring?1:0,productionIntensity:production};
+}
+
+export function scoreSignal(signal:ToolSignals):ScoreResult {
+  const d=dimensionsFromSignal(signal);
+  const raw=SIGNAL_UNIT*(d.severity/HARD_SEVERITY+d.spinning+d.exploring-d.productionIntensity);
+  const score=Math.tanh(SCORE_GAIN*raw);
+  return {score,confidence:Math.abs(score)};
+}
+
+export function pickTier(signal:ToolSignals, mode:PickerMode='efficient_first', confidenceThreshold=0.5):PickOutcome {
+  const defaultTier:Tier=mode==='capable_first'?'capable':'efficient';
+  if(signal.compacted||signal.severity>=SEVERITY_CRITICAL||signal.repeatedFailure)
+    return {kind:'resolved',tier:'capable',source:'override',probability:0.5,confidence:1};
+  const scored=scoreSignal(signal); const probability=(scored.score+1)/2; const half=confidenceThreshold/2;
+  if(probability>0.5+half||probability<0.5-half)
+    return {kind:'resolved',tier:probability>0.5?'capable':'efficient',source:'dimensions',probability,confidence:scored.confidence};
+  return {kind:'consult_classifier',probability,confidence:scored.confidence,defaultTier};
+}
+
+export function handoffNoteFor(tier:Tier, source:DecisionSource, config:HandoffNoteConfig):string|undefined {
+  if(tier==='capable') {
+    const signalDriven=source==='override'||source==='dimensions';
+    return (config.onlyOnWrongSignalEscalation??true)&&!signalDriven ? undefined : config.escalationNote;
+  }
+  return config.deescalationNote;
+}
+
+/** Apply stage hard rules, dimension scoring, and the capable recovery hold. */
+export function selectStage(signal:ToolSignals, options:StageOptions={}, state:StageState={capableHoldTurnsRemaining:0}):StageDecision {
+  const mode=options.mode??'efficient_first'; const defaultTier:Tier=mode==='capable_first'?'capable':'efficient';
+  const holdTurns=Math.max(0,Math.trunc(options.capableHoldTurns??2));
+  let remaining=Math.max(0,Math.trunc(state.capableHoldTurnsRemaining));
+  const cleanTestPass=signal.testsPassed&&signal.noErrorStreak>0;
+  if(cleanTestPass)remaining=0;
+  let outcome:PickOutcome;
+  if(!cleanTestPass&&remaining>0){remaining--;outcome={kind:'resolved',tier:'capable',source:'capable_hold',probability:0.5,confidence:1};}
+  else outcome=pickTier(signal,mode,options.confidenceThreshold??0.5);
+  if(outcome.kind==='resolved'&&outcome.tier==='capable'&&(outcome.source==='override'||outcome.source==='dimensions'))remaining=holdTurns;
+  const dimensions=dimensionsFromSignal(signal); const score=scoreSignal(signal).score;
+  const note = outcome.kind === 'resolved' && options.handoffNotes
+    ? handoffNoteFor(outcome.tier, outcome.source, options.handoffNotes)
+    : undefined;
+  return {
+    tier: outcome.kind === 'resolved' ? outcome.tier : undefined,
+    defaultTier,
+    source: outcome.kind === 'consult_classifier' ? 'ambiguous' : outcome.source,
+    probability: outcome.probability,
+    confidence: outcome.confidence ?? 0,
+    score,
+    dimensions,
+    ...(note === undefined ? {} : { note }),
+    state: { capableHoldTurnsRemaining: remaining },
+  };
+}

package/src/models/route/state.ts

@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+// Ported to TypeScript from NVIDIA NeMo Switchyard crates/libsy/src/algorithms/escalation.rs at commit c8848511, modified.
+
+import type { EscalationCategory, EscalationVerdict } from "./escalation.ts";
+
+export interface EscalationStateSnapshot { latched: boolean; category?: EscalationCategory; streak: number }
+
+/** Confirmation streak and session latch used by the trajectory escalation policy. */
+export class EscalationState {
+  private category?: EscalationCategory;
+  private streak = 0;
+  private latched = false;
+  apply(verdict: EscalationVerdict | undefined, confirmations = 2): EscalationStateSnapshot {
+    if (this.latched) return this.snapshot();
+    if (verdict && verdict.escalate && verdict.category !== "none" && verdict.newEvidence) {
+      this.streak = this.category === verdict.category ? this.streak + 1 : 1;
+      this.category = verdict.category;
+      if (this.streak >= confirmations) this.latched = true;
+    } else if (verdict) {
+      this.streak = 0;
+      this.category = undefined;
+    }
+    return this.snapshot();
+  }
+  reset(): void { this.category = undefined; this.streak = 0; this.latched = false; }
+  snapshot(): EscalationStateSnapshot { return { latched: this.latched, ...(this.category ? { category: this.category } : {}), streak: this.streak }; }
+}
+
+/** Bounded keyed state helper with one-hour idle expiry for independent sessions. */
+export class SessionState<T> {
+  private readonly values = new Map<string, { value: T; touchedAt: number }>();
+  constructor(private readonly maxEntries = 1024, private readonly ttlMs = 60 * 60 * 1000) {}
+  get(key: string, now = Date.now()): T | undefined {
+    this.expire(now);
+    const entry = this.values.get(key);
+    if (entry) entry.touchedAt = now;
+    return entry?.value;
+  }
+  set(key: string, value: T, now = Date.now()): void {
+    this.expire(now);
+    this.values.delete(key);
+    while (this.values.size >= this.maxEntries) {
+      const oldest = this.values.keys().next().value;
+      if (oldest === undefined) break;
+      this.values.delete(oldest);
+    }
+    this.values.set(key, { value, touchedAt: now });
+  }
+  delete(key: string): void { this.values.delete(key); }
+  private expire(now: number): void {
+    for (const [key, entry] of this.values) if (now - entry.touchedAt >= this.ttlMs) this.values.delete(key);
+  }
+}

package/src/models/route/text.ts

@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+// Ported to TypeScript from NVIDIA NeMo Switchyard crates/libsy/src/algorithms/advisor_gate/transcript.rs and algorithms/util/{escalation,prompts,llm_judge}.rs at commit c8848511, modified.
+
+import type { ChatMessage } from "../../omniroute/client.ts";
+
+/** Unicode code-point aware middle truncation used by Switchyard's advisor. */
+export function middleDrop(text: string, cap: number): string {
+  const chars = Array.from(text);
+  if (chars.length <= cap) return text;
+  const headCount = Math.max(0, Math.floor(cap / 4));
+  const tailCount = Math.max(0, cap - headCount);
+  return `${chars.slice(0, headCount).join("")}\n...<middle of the conversation truncated>...\n${chars.slice(-tailCount || chars.length).join("")}`;
+}
+
+/** Bounded head/tail truncation for escalation summaries, measured in code points. */
+export function truncateCodepoints(text: string, limit: number): string {
+  const chars = Array.from(text);
+  if (chars.length <= limit) return text;
+  const marker = " ...[trimmed] ";
+  const keep = Math.min(chars.length, Math.max(20, limit - Array.from(marker).length));
+  const head = Math.floor(keep * 2 / 3);
+  const tail = keep - head;
+  return `${chars.slice(0, head).join("")}${marker}${chars.slice(-tail).join("")}`;
+}
+
+const verdictPattern = /^[\s*_#>"'(\[`]*(?:(?:final\s+)?verdict\s*:\s*[\s*_#>"'(\[`]*)?(APPROVE|REDO)(?![\p{Alphabetic}\p{M}\p{Nd}\p{Pc}\p{Join_Control}])/iu;
+
+export type AdvisorVerdict = { kind: "approve" } | { kind: "redo"; plan: string };
+
+/** Only an anchored first-word verdict is trusted. */
+export function parseAdvisorVerdict(reply: string): AdvisorVerdict | undefined {
+  const trimmed = reply.trim();
+  const match = verdictPattern.exec(trimmed);
+  if (!match) return undefined;
+  if (match[1]?.toUpperCase() === "APPROVE") return { kind: "approve" };
+  const tail = trimmed.slice(match[0].length).trimStart().replace(/^[ *_:\n-]+/u, "").trim();
+  return { kind: "redo", plan: tail || trimmed };
+}
+
+/** Removes only the JSON fences supported by Switchyard's typed judge parser. */
+export function stripJsonFence(text: string): string {
+  let value = text.trim();
+  if (!value.startsWith("```")) return value;
+  value = value.slice(3);
+  if (value.startsWith("json")) value = value.slice(4);
+  value = value.replace(/^[\n\r]+/u, "");
+  return value.endsWith("```") ? value.slice(0, -3).trim() : value;
+}
+
+/** Add a routing note without creating consecutive user turns. */
+export function appendNote(messages: readonly ChatMessage[], note: string): ChatMessage[] {
+  const output = messages.map(message => ({ ...message }));
+  const last = output.at(-1);
+  if (last?.role === "user") {
+    last.content = last.content ? `${last.content}\n${note}` : note;
+  } else {
+    output.push({ role: "user", content: note });
+  }
+  return output;
+}

package/src/omniroute/client.ts

@@ -24,8 +24,12 @@ export interface ChatMessage {
   content: string | null;
   tool_calls?: ToolCall[];
   tool_call_id?: string;
+  /** Internal local-tool outcome, consumed by route normalization and omitted from provider transport. */
+  is_error?: boolean;
 }
 export interface ChatResult {
+  /** Internal routing telemetry id, never part of a provider payload. */
+  routeDecision?: string;
   message: ChatMessage;
   /** Usage counters returned by the provider, when valid. No missing counter is inferred as zero. */
   usage?: NormalizedUsage;
@@ -37,6 +41,8 @@ export interface ChatResult {
   selectedModel?: string;
 }
 export interface ChatOptions {
+  /** Refuse a changed/off-campus gateway immediately before transport. */
+  onCampusOnly?: boolean;
   signal?: AbortSignal;
   /** Switchyard base (`http://127.0.0.1:<port>/v1`). The sidecar holds the key, so none is sent. */
   via?: string;
@@ -155,6 +161,7 @@ export class OmniRoute {
   async chat(body: { model: string; messages: ChatMessage[]; tools?: unknown[]; max_tokens?: number }, opts: ChatOptions = {}): Promise<ChatResult> {
     const base = opts.via ?? (await this.base());
     if (!base) throw new Error("no model gateway is configured or reachable (omniroute.urls in .agenthub/config.json; see ahub doctor)");
+    if (opts.onCampusOnly && (opts.via || this.isAccessHost(base))) throw new Error("PII model calls require the confirmed campus gateway");
     const headers: Record<string, string> = { "content-type": "application/json" };
     if (opts.via) {
       if (opts.sessionId) headers["x-switchyard-session-id"] = opts.sessionId;
@@ -168,7 +175,7 @@ export class OmniRoute {
       res = await fetch(`${base}/chat/completions`, {
         method: "POST",
         headers,
-        body: JSON.stringify({ ...body, stream: false }),
+        body: JSON.stringify({ ...body, messages: body.messages.map(({ is_error: _internalError, ...message }) => message), stream: false }),
         ...(opts.signal ? { signal: opts.signal } : {}),
       });
     } catch (e) {

package/templates/routing.toml

@@ -93,3 +93,31 @@ peers = ["pi", "local", "kimi"]
 route = "sy/fast"
 pi_backend = "mlx"
 escalate_to = ["codex", "kimi"]
+
+# In-process L2 routes are opt-in: set local.route or a class route to hub/<id>.
+# They never enter the optional Switchyard sidecar TOML. Defaults are efficient fast, capable coding.
+[hub_routes."hub/stage"]
+type = "stage"
+efficient = "fast"
+capable = "coding"
+confidence_threshold = 0.5
+hold_turns = 2
+
+[hub_routes."hub/plan"]
+type = "plan_execute"
+efficient = "fast"
+capable = "coding"
+
+[hub_routes."hub/advisor"]
+type = "advisor"
+efficient = "fast"
+capable = "coding"
+max_reviews = 1
+trigger = "no_tool_call"
+gate_min_tool_results = 1
+
+[hub_routes."hub/escalation"]
+type = "escalation"
+efficient = "fast"
+capable = "coding"
+confirmations = 2