atris 3.34.0 → 3.36.0

package/lib/receipt-evidence.js

@@ -16,11 +16,65 @@ const MAX_RECEIPTS = 5;
 function receiptVerifierPassed(receipt) {
   const result = receipt?.result;
   if (!result || typeof result !== 'object') return null;
-  if (result.passed === true || result.verifier_result?.passed === true || result.tick?.verifier_passed === true) return true;
-  if (result.passed === false || result.verifier_result?.passed === false || result.tick?.verifier_passed === false) return false;
+  const oneLapReview = receipt?.schema === 'atris.dispatch_receipt.v1'
+    && receipt?.review_only === true
+    && receipt?.context?.source === 'one_lap';
+  if (oneLapReview) {
+    const validator = result.validator_result;
+    const validatorEngine = String(validator?.engine || '').trim();
+    const executorEngine = String(validator?.executor_engine || '').trim();
+    return result.passed === true
+      && result.master_boundary_enforced === true
+      && result.master_unchanged === true
+      && validator?.passed === true
+      && validator?.independent === true
+      && validator?.worktree_unchanged === true
+      && Boolean(validatorEngine)
+      && Boolean(executorEngine)
+      && validatorEngine !== executorEngine;
+  }
+  // The receipt's aggregate result is authoritative. A nested verifier can
+  // explain one green check inside a failed flight, but it cannot turn that
+  // failed flight into passing evidence.
+  if (typeof result.passed === 'boolean') return result.passed;
+  const nested = [result.verifier_result?.passed, result.tick?.verifier_passed];
+  if (nested.includes(false)) return false;
+  if (nested.includes(true)) return true;
   return null;
 }
 
+// A forced completion means the mission's own gate said no and an operator
+// overrode it. The receipt can still show a passing verifier, so the forced
+// flag lives in mission state (`completion_gate.forced`); read it back here
+// so the review queue shows forced work as forced, not as passing evidence.
+function loadForcedMissionIds(root) {
+  const forced = new Map();
+  let raw;
+  try {
+    raw = fs.readFileSync(path.resolve(root, '.atris/state/missions.jsonl'), 'utf8');
+  } catch {
+    return forced;
+  }
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let parsed = null;
+    try { parsed = JSON.parse(line); } catch { continue; }
+    const mission = parsed?.mission && typeof parsed.mission === 'object' ? parsed.mission : parsed;
+    const id = mission?.id || parsed?.mission_id;
+    if (!id) continue;
+    // Last record for a mission wins: an honest re-completion clears the flag.
+    forced.set(id, mission?.completion_gate?.forced === true);
+  }
+  return forced;
+}
+
+function receiptForced(receipt, forcedMissionIds) {
+  if (receipt?.completion_gate?.forced === true) return true;
+  if (receipt?.mission?.completion_gate?.forced === true) return true;
+  const missionId = receipt?.mission_id || receipt?.mission?.id;
+  return Boolean(missionId && forcedMissionIds.get(missionId) === true);
+}
+
 function extractReceiptEvidence(proofText, root = process.cwd()) {
   const text = String(proofText || '');
   const found = [];
@@ -37,6 +91,7 @@ function extractReceiptEvidence(proofText, root = process.cwd()) {
 
   const receipts = [];
   const missing = [];
+  let forcedMissionIds = null;
   for (const rel of found) {
     let raw;
     try {
@@ -51,13 +106,19 @@ function extractReceiptEvidence(proofText, root = process.cwd()) {
     const passed = receiptVerifierPassed(parsed);
     if (passed !== null) entry.verifier_passed = passed;
     if (parsed?.mission_id) entry.mission_id = parsed.mission_id;
+    if (forcedMissionIds === null) forcedMissionIds = loadForcedMissionIds(root);
+    if (receiptForced(parsed, forcedMissionIds)) entry.forced = true;
     receipts.push(entry);
   }
+  const anyForced = receipts.some((entry) => entry.forced === true);
   return {
     receipts,
     missing,
-    // True only when every named receipt exists and none shows a failing verifier.
-    all_passing: receipts.length > 0 && !missing.length && receipts.every((entry) => entry.verifier_passed !== false),
+    any_forced: anyForced,
+    // Unknown verifier state is not proof, and a forced completion is not
+    // passing evidence: every named receipt must explicitly pass, unforced.
+    all_passing: receipts.length > 0 && !missing.length && !anyForced
+      && receipts.every((entry) => entry.verifier_passed === true),
   };
 }
 

package/lib/review-integrity.js

@@ -0,0 +1,147 @@
+'use strict';
+
+// judge != worker: the builder of a task cannot be the actor whose review
+// pass certifies or lands it. This module is the single home for actor
+// identity rules; task-db, auto-accept, and the task CLI all lean on it.
+// Level 1 trust: normalized string identity + builder exclusion + reserved
+// system names + roster validation (warn by default). It stops accidental
+// and lazy self-judging and makes deliberate spoofing auditable; signed
+// events (level 2) are a follow-up, not this file.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const functionalOwner = require('./functional-owner');
+
+// System actors written by the machinery itself; a human or agent may never
+// claim/ready/review under these names.
+const RESERVED_ACTORS = new Set(['autoland-verifier', 'auto-accept-certified']);
+
+function normalizeActor(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function envActor() {
+  return normalizeActor(process.env.ATRIS_AGENT_ID || process.env.USER || '');
+}
+
+// Builder identity, oldest signal wins: explicit stamp, then who claimed it,
+// then whoever sent the first proof.
+function taskBuilder(task) {
+  if (!task || typeof task !== 'object') return null;
+  const metadata = task.metadata || {};
+  const stamped = normalizeActor(metadata.built_by);
+  if (stamped) return stamped;
+  const claimed = normalizeActor(task.claimed_by);
+  if (claimed) return claimed;
+  for (const event of task.events || []) {
+    if (event && event.event_type === 'proof_ready') {
+      const actor = normalizeActor(event.actor || (event.payload && event.payload.actor));
+      if (actor) return actor;
+    }
+  }
+  return null;
+}
+
+function reviewEventActors(task) {
+  const actors = new Set();
+  for (const event of (task && task.events) || []) {
+    if (!event || !['proof_ready', 'reviewed'].includes(event.event_type)) continue;
+    const actor = normalizeActor(event.actor || (event.payload && event.payload.actor));
+    if (actor) actors.add(actor);
+  }
+  return actors;
+}
+
+// Actors who reviewed the task and are not its builder.
+function independentReviewActors(task) {
+  const builder = taskBuilder(task);
+  const actors = reviewEventActors(task);
+  if (builder) actors.delete(builder);
+  return actors;
+}
+
+// True when at least one review pass came from someone other than the
+// builder. When the builder cannot be resolved at all, fall back to
+// requiring two distinct actors — independence cannot be proven from one.
+function hasIndependentReview(task) {
+  const builder = taskBuilder(task);
+  if (!builder) return reviewEventActors(task).size >= 2;
+  return independentReviewActors(task).size >= 1;
+}
+
+function isReservedActor(actor) {
+  return RESERVED_ACTORS.has(normalizeActor(actor));
+}
+
+function rosterActors(root) {
+  const actors = new Set(functionalOwner.listWorkspaceMemberSlugs(root));
+  for (const id of ['atris-2-fast', 'atris2', 'atris2-fast', 'claude', 'codex', 'codex-executor', 'cursor', 'devin', 'executor', 'openclaw', 'windsurf']) {
+    actors.add(id);
+  }
+  try {
+    const user = normalizeActor(os.userInfo().username);
+    if (user) actors.add(user);
+  } catch (_) { /* identity lookup can fail in stripped containers */ }
+  const envUser = normalizeActor(process.env.USER);
+  if (envUser) actors.add(envUser);
+  const agentId = normalizeActor(process.env.ATRIS_AGENT_ID);
+  if (agentId) actors.add(agentId);
+  try {
+    const policyPath = path.join(root || process.cwd(), '.atris', 'policy', 'autoland.json');
+    const policy = JSON.parse(fs.readFileSync(policyPath, 'utf8'));
+    const enabledBy = normalizeActor(policy.enabled_by);
+    if (enabledBy) actors.add(enabledBy);
+  } catch (_) { /* no policy is fine */ }
+  return actors;
+}
+
+// off | warn | enforce. Env wins, then .atris/review-policy.json, then off.
+// Off by default on purpose: ad-hoc --as names are everywhere in scripts and
+// fixtures, and a warning that fires on legitimate flows teaches everyone to
+// ignore warnings (the cry-wolf lesson). Reserved-actor rejection and
+// builder-exclusion do not depend on this mode and are always enforced.
+function actorValidationMode(root) {
+  const env = String(process.env.ATRIS_ACTOR_VALIDATION || '').toLowerCase();
+  if (['off', 'warn', 'enforce'].includes(env)) return env;
+  try {
+    const policyPath = path.join(root || process.cwd(), '.atris', 'review-policy.json');
+    const policy = JSON.parse(fs.readFileSync(policyPath, 'utf8'));
+    const mode = String(policy.actor_validation || '').toLowerCase();
+    if (['off', 'warn', 'enforce'].includes(mode)) return mode;
+  } catch (_) { /* no policy is fine */ }
+  return 'off';
+}
+
+// Reserved names are rejected in every mode; unknown names pass in warn mode
+// (with ok true + reason so callers can print) and fail in enforce mode.
+function validateActor(actor, { root } = {}) {
+  const normalized = normalizeActor(actor);
+  if (!normalized) return { ok: true, mode: 'off', actor: normalized };
+  if (isReservedActor(normalized)) {
+    return { ok: false, mode: 'enforce', actor: normalized, reason: 'reserved_actor' };
+  }
+  const mode = actorValidationMode(root);
+  if (mode === 'off') return { ok: true, mode, actor: normalized };
+  if (rosterActors(root).has(normalized)) return { ok: true, mode, actor: normalized };
+  if (mode === 'enforce') return { ok: false, mode, actor: normalized, reason: 'actor_not_on_roster' };
+  return { ok: true, mode, actor: normalized, reason: 'actor_not_on_roster' };
+}
+
+module.exports = {
+  RESERVED_ACTORS,
+  normalizeActor,
+  envActor,
+  taskBuilder,
+  reviewEventActors,
+  independentReviewActors,
+  hasIndependentReview,
+  isReservedActor,
+  rosterActors,
+  actorValidationMode,
+  validateActor,
+};

package/lib/router-brain.js

@@ -0,0 +1,352 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_MIN_RECEIPTS = 3;
+const DEFAULT_HALF_LIFE_MS = 30 * 24 * 60 * 60 * 1000;
+const DURATION_SCALE_MS = 60 * 1000;
+
+function objectValue(value) {
+  return value && typeof value === 'object' ? value : null;
+}
+
+function recordContainers(record) {
+  const row = objectValue(record);
+  if (!row) return [];
+  return [
+    row,
+    objectValue(row.payload),
+    objectValue(row.result),
+    objectValue(row.tick),
+    objectValue(row.result?.tick),
+    objectValue(row.payload?.tick),
+    objectValue(row.verifier_result),
+    objectValue(row.result?.verifier_result),
+    objectValue(row.payload?.verifier_result),
+    objectValue(row.mission),
+    objectValue(row.context),
+  ].filter(Boolean);
+}
+
+function firstField(containers, names, accept = (value) => value != null) {
+  for (const container of containers) {
+    for (const name of names) {
+      const value = container[name];
+      if (accept(value)) return value;
+    }
+  }
+  return null;
+}
+
+function normalizedLabel(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function finiteNonnegative(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : null;
+}
+
+function recordDuration(containers) {
+  const direct = firstField(
+    containers,
+    ['duration_ms', 'durationMs', 'elapsed_ms', 'elapsedMs'],
+    (value) => finiteNonnegative(value) !== null,
+  );
+  if (direct !== null) return finiteNonnegative(direct);
+  for (const container of containers) {
+    const started = Date.parse(String(container.started_at || container.startedAt || ''));
+    const finished = Date.parse(String(container.finished_at || container.finishedAt || ''));
+    if (Number.isFinite(started) && Number.isFinite(finished) && finished >= started) {
+      return finished - started;
+    }
+  }
+  return null;
+}
+
+function recordTimestamp(containers, fallbackMs) {
+  const raw = firstField(containers, [
+    'at',
+    'ts',
+    'finished_at',
+    'finishedAt',
+    'created_at',
+    'createdAt',
+    'updated_at',
+    'updatedAt',
+    'started_at',
+    'startedAt',
+  ]);
+  const parsed = Date.parse(String(raw || ''));
+  if (Number.isFinite(parsed)) return parsed;
+  return Number.isFinite(fallbackMs) ? fallbackMs : Date.now();
+}
+
+function observationFromRecord(record, source, fallbackMs) {
+  const containers = recordContainers(record);
+  const engine = normalizedLabel(firstField(containers, [
+    'engine_id',
+    'engine',
+    'selected_engine',
+    'executor_engine',
+    'runner',
+  ]));
+  const taskType = normalizedLabel(firstField(containers, [
+    'task_type',
+    'taskType',
+    'job_type',
+    'jobType',
+    'role',
+    'kind',
+  ]));
+  const passed = firstField(
+    containers,
+    ['verified_passed', 'verifier_passed', 'passed', 'verified'],
+    (value) => typeof value === 'boolean',
+  );
+  if (!engine || !taskType || typeof passed !== 'boolean') return null;
+  return {
+    engine,
+    task_type: taskType,
+    verified_passed: passed,
+    duration_ms: recordDuration(containers),
+    at_ms: recordTimestamp(containers, fallbackMs),
+    source,
+  };
+}
+
+function readTaskReceiptObservations(root) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  let entries;
+  try {
+    entries = fs.readdirSync(runsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const observations = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.json') || !entry.name.includes('task-')) continue;
+    const file = path.join(runsDir, entry.name);
+    try {
+      const stat = fs.statSync(file);
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const observation = observationFromRecord(parsed, path.relative(root, file), stat.mtimeMs);
+      if (observation) observations.push(observation);
+    } catch {}
+  }
+  return observations;
+}
+
+function readMissionEventObservations(root) {
+  const file = path.join(root, '.atris', 'state', 'mission_events.jsonl');
+  let raw;
+  let fallbackMs = Date.now();
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+    fallbackMs = fs.statSync(file).mtimeMs;
+  } catch {
+    return [];
+  }
+  const observations = [];
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const observation = observationFromRecord(JSON.parse(line), path.relative(root, file), fallbackMs);
+      if (observation) observations.push(observation);
+    } catch {}
+  }
+  return observations;
+}
+
+function readDispatchReceiptObservations(root) {
+  const runsDir = path.join(root, 'atris', 'runs');
+  let entries;
+  try {
+    entries = fs.readdirSync(runsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const observations = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.startsWith('dispatch-') || !entry.name.endsWith('.json')) continue;
+    const file = path.join(runsDir, entry.name);
+    try {
+      const stat = fs.statSync(file);
+      const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+      const results = Array.isArray(parsed?.results) ? parsed.results : [];
+      for (const [index, row] of results.entries()) {
+        if (typeof row?.verified_passed !== 'boolean') continue;
+        const source = `${path.relative(root, file)}#results[${index}]`;
+        const observation = observationFromRecord(row, source, stat.mtimeMs);
+        if (observation) observations.push(observation);
+      }
+    } catch {}
+  }
+  return observations;
+}
+
+function loadRouterHistory(root = process.cwd()) {
+  return [
+    ...readTaskReceiptObservations(root),
+    ...readMissionEventObservations(root),
+    ...readDispatchReceiptObservations(root),
+  ];
+}
+
+function median(values) {
+  const sorted = values
+    .map(finiteNonnegative)
+    .filter((value) => value !== null)
+    .sort((left, right) => left - right);
+  if (!sorted.length) return null;
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2
+    ? sorted[middle]
+    : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+
+function historyKey(engine, taskType) {
+  return `${normalizedLabel(engine)}\u0000${normalizedLabel(taskType)}`;
+}
+
+function computeEngineTaskStats(observations, options = {}) {
+  const nowValue = options.now instanceof Date ? options.now.getTime() : Number(options.now ?? Date.now());
+  const nowMs = Number.isFinite(nowValue) ? nowValue : Date.now();
+  const halfLifeValue = Number(options.halfLifeMs ?? DEFAULT_HALF_LIFE_MS);
+  const halfLifeMs = Number.isFinite(halfLifeValue) && halfLifeValue > 0
+    ? halfLifeValue
+    : DEFAULT_HALF_LIFE_MS;
+  const groups = new Map();
+  for (const row of Array.isArray(observations) ? observations : []) {
+    const engine = normalizedLabel(row?.engine);
+    const taskType = normalizedLabel(row?.task_type || row?.taskType);
+    if (!engine || !taskType || typeof row?.verified_passed !== 'boolean') continue;
+    const key = historyKey(engine, taskType);
+    const group = groups.get(key) || { engine, task_type: taskType, receipts: [] };
+    group.receipts.push(row);
+    groups.set(key, group);
+  }
+
+  return [...groups.values()].map((group) => {
+    let weightedPasses = 0;
+    let totalWeight = 0;
+    let verifiedPasses = 0;
+    for (const receipt of group.receipts) {
+      const atMs = Number(receipt.at_ms);
+      const ageMs = Number.isFinite(atMs) ? Math.max(0, nowMs - atMs) : halfLifeMs;
+      const weight = Math.pow(0.5, ageMs / halfLifeMs);
+      totalWeight += weight;
+      if (receipt.verified_passed) {
+        verifiedPasses += 1;
+        weightedPasses += weight;
+      }
+    }
+    const receiptCount = group.receipts.length;
+    const passRate = verifiedPasses / receiptCount;
+    const weightedPassRate = totalWeight > 0 ? weightedPasses / totalWeight : passRate;
+    const medianDurationMs = median(group.receipts.map((receipt) => receipt.duration_ms));
+    const durationScore = medianDurationMs === null
+      ? 0
+      : 1 / (1 + (medianDurationMs / DURATION_SCALE_MS));
+    return {
+      engine: group.engine,
+      task_type: group.task_type,
+      receipt_count: receiptCount,
+      verified_passes: verifiedPasses,
+      verified_failures: receiptCount - verifiedPasses,
+      verified_pass_rate: passRate,
+      median_duration_ms: medianDurationMs,
+      recency_weighted_score: (weightedPassRate * 0.85) + (durationScore * 0.15),
+    };
+  }).sort((left, right) => left.engine.localeCompare(right.engine)
+    || left.task_type.localeCompare(right.task_type));
+}
+
+function candidateId(candidate) {
+  return normalizedLabel(typeof candidate === 'string' ? candidate : candidate?.id || candidate?.name);
+}
+
+function fallbackOrder(candidate, index) {
+  const value = Number(candidate && typeof candidate === 'object' ? candidate.fallback_order : NaN);
+  return Number.isFinite(value) ? value : index;
+}
+
+function legacyRank(candidates) {
+  return candidates
+    .map((candidate, index) => ({ candidate, index }))
+    .sort((left, right) => fallbackOrder(left.candidate, left.index) - fallbackOrder(right.candidate, right.index)
+      || candidateId(left.candidate).localeCompare(candidateId(right.candidate)))
+    .map((entry) => entry.candidate);
+}
+
+function rankEnginesDetailed(candidates, options = {}) {
+  const input = Array.isArray(candidates) ? candidates : [];
+  const legacy = legacyRank(input);
+  const taskType = normalizedLabel(options.taskType || options.task_type);
+  const minValue = Number(options.minReceipts ?? DEFAULT_MIN_RECEIPTS);
+  const minReceipts = Number.isInteger(minValue) && minValue > 0 ? minValue : DEFAULT_MIN_RECEIPTS;
+  const observations = Array.isArray(options.observations)
+    ? options.observations
+    : loadRouterHistory(options.root || process.cwd());
+  const stats = computeEngineTaskStats(observations, options);
+  const statsByEngine = new Map(stats
+    .filter((row) => row.task_type === taskType)
+    .map((row) => [row.engine, row]));
+  const thinEngines = legacy
+    .map(candidateId)
+    .filter((engine) => !statsByEngine.has(engine) || statsByEngine.get(engine).receipt_count < minReceipts);
+
+  if (!taskType || thinEngines.length) {
+    return {
+      candidates: legacy,
+      stats,
+      task_type: taskType,
+      used_track_record: false,
+      thin_engines: thinEngines,
+    };
+  }
+
+  const ranked = legacy
+    .map((candidate, index) => ({ candidate, index, stats: statsByEngine.get(candidateId(candidate)) }))
+    .sort((left, right) => right.stats.recency_weighted_score - left.stats.recency_weighted_score
+      || fallbackOrder(left.candidate, left.index) - fallbackOrder(right.candidate, right.index)
+      || candidateId(left.candidate).localeCompare(candidateId(right.candidate)))
+    .map((entry) => entry.candidate);
+  return {
+    candidates: ranked,
+    stats,
+    task_type: taskType,
+    used_track_record: true,
+    thin_engines: [],
+  };
+}
+
+function rankEngines(candidates, options = {}) {
+  return rankEnginesDetailed(candidates, options).candidates;
+}
+
+function routerPickExplanation(decision) {
+  const winner = decision?.candidates?.[0];
+  const engine = candidateId(winner);
+  if (!engine) return '';
+  const taskType = normalizedLabel(decision.task_type) || 'work';
+  if (!decision.used_track_record) {
+    return `router picked ${engine} because ${taskType} track records are thin, so fallback order applies.`;
+  }
+  const stats = decision.stats.find((row) => row.engine === engine && row.task_type === taskType);
+  if (!stats) return `router picked ${engine} because it has the strongest ${taskType} track record.`;
+  const passRate = (stats.verified_pass_rate * 100).toFixed(1);
+  const duration = stats.median_duration_ms === null ? 'no duration' : `${Math.round(stats.median_duration_ms)} ms median`;
+  return `router picked ${engine} because ${stats.receipt_count} ${taskType} receipts scored ${stats.recency_weighted_score.toFixed(3)} with a ${passRate}% verified pass rate and ${duration}.`;
+}
+
+module.exports = {
+  DEFAULT_MIN_RECEIPTS,
+  DEFAULT_HALF_LIFE_MS,
+  loadRouterHistory,
+  computeEngineTaskStats,
+  rankEngines,
+  rankEnginesDetailed,
+  routerPickExplanation,
+};

package/lib/runner-command.js

@@ -40,11 +40,43 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     model: '',
     commandTemplate: '{bin} --trust -p {prompt}',
   }),
+  // Compatibility names for fleet rosters. These map to real installed
+  // runners instead of retired or UI-only model names.
+  fable: Object.freeze({
+    bin: 'claude',
+    model: '',
+    commandTemplate: '',
+  }),
+  composer: Object.freeze({
+    bin: 'ax',
+    model: 'composer-2-5-fast',
+    commandTemplate: '{bin} --fast {prompt}',
+  }),
+  haiku: Object.freeze({
+    bin: 'claude',
+    model: 'claude-haiku-4-5',
+    commandTemplate: '',
+  }),
   devin: Object.freeze({
     bin: 'devin',
     model: '',
     commandTemplate: '{bin} -p -- {prompt}',
   }),
+  grok: Object.freeze({
+    bin: 'grok',
+    model: 'grok-4.5',
+    commandTemplate: '{bin} --always-approve -p {prompt}',
+  }),
+  hermes: Object.freeze({
+    bin: 'hermes',
+    model: '',
+    commandTemplate: '{bin} -p -- {prompt}',
+  }),
+  droid: Object.freeze({
+    bin: 'droid',
+    model: '',
+    commandTemplate: '{bin} exec {prompt}',
+  }),
 });
 
 // Alias -> canonical profile name. Every alias resolves to the same config as
@@ -53,6 +85,7 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
 const RUNNER_PROFILE_ALIASES = Object.freeze({
   'atris2-fast': 'atris-fast',
   'atris-2-fast': 'atris-fast',
+  'hermes-agent': 'hermes',
 });
 
 // Back-compat surface: RUNNER_PROFILES still resolves every accepted name