@monoes/monomindcli 2.13.0 → 2.14.0

package/dist/src/ui/org-hil.mjs

@@ -0,0 +1,276 @@
+// Human-in-the-loop actions for the dashboard: approvals, decision gates,
+// ask_human answers and human chat messages for Org Runtime v2 orgs.
+//
+// Same shape as the `monomind org approve|deny|gate-*|answer` commands
+// (commands/org-observe.ts): when a daemon hosts the org, the decision goes to
+// its operator-only routes with the operator credential, and the daemon both
+// records it and wakes the waiting role. When no daemon hosts the org, the
+// decision is recorded in the org's own files, where the next run finds it.
+// Unlike the CLI, a live daemon that REJECTS the call is reported as an error
+// instead of falling back to a file write the daemon would overwrite.
+import fs from 'node:fs';
+import path from 'node:path';
+// Compiled from orgrt/*.ts, like forwarder.js in routes-org.mjs.
+import { lookupOrg, readOperatorCredential } from '../orgrt/broker.js';
+import { queueMessage } from '../orgrt/inbox.js';
+
+/** Recorded as resolvedBy on everything decided here (normalizeResolver-valid). */
+export const DASHBOARD_RESOLVER = 'human:dashboard';
+
+const orgDir = (root, org) => path.join(root, '.monomind', 'orgs', org);
+
+class HilError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+
+/** Read `<orgDir>/<file>` → its `key` array. Missing file → []. A file that
+ *  exists but can't be parsed THROWS: callers rewrite what this returns, and
+ *  rewriting from [] would erase every other entry. */
+function readList(root, org, file, key) {
+  const p = path.join(orgDir(root, org), file);
+  let raw;
+  try {
+    raw = fs.readFileSync(p, 'utf8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw new HilError(500, `cannot read ${p}: ${err.message}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new HilError(500, `${p} is not valid JSON (${err.message})`);
+  }
+  const list = parsed?.[key] ?? [];
+  if (!Array.isArray(list)) throw new HilError(500, `${p}: "${key}" is not an array`);
+  return list;
+}
+
+function writeList(root, org, file, key, list) {
+  const dir = orgDir(root, org);
+  fs.mkdirSync(dir, { recursive: true });
+  const dest = path.join(dir, file);
+  const tmp = `${dest}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ [key]: list }, null, 2));
+  fs.renameSync(tmp, dest);
+}
+
+/** POST to the hosting daemon's operator-only `route`. Returns null when no
+ *  live daemon hosts `org`; otherwise the daemon's verdict. */
+async function callDaemon(org, route, body) {
+  const remote = lookupOrg(org);
+  if (!remote) return null;
+  const cred = readOperatorCredential(org);
+  if (!cred)
+    throw new HilError(
+      503,
+      `org "${org}" is running, but its operator credential (~/.monomind/orgrt-operator/${org}.json) is missing — the dashboard cannot act for a human`,
+    );
+  let res;
+  try {
+    res = await fetch(`${remote.url}${route}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'x-monomind-cred': cred },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(10_000),
+    });
+  } catch (err) {
+    throw new HilError(502, `org "${org}" daemon unreachable: ${err.message}`);
+  }
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok || !data.ok)
+    throw new HilError(
+      res.status >= 400 ? res.status : 502,
+      data.error || `daemon returned ${res.status}`,
+    );
+  return data;
+}
+
+function approvalStatus(a) {
+  if (a.approved === true) return 'approved';
+  if (a.approved === false) return 'denied';
+  return 'pending';
+}
+
+/** The org's tool/action approvals (`<org>/approvals.json`), newest first. */
+export function listApprovals(root, org) {
+  return readList(root, org, 'approvals.json', 'approvals')
+    .map((a) => ({
+      id: a.requestId || null,
+      roleId: a.roleId,
+      action: a.action,
+      input: a.input || null,
+      status: approvalStatus(a),
+      ts: a.ts || null,
+      resolvedBy: a.resolvedBy || null,
+      resolvedAt: a.resolvedAt || null,
+    }))
+    .sort((a, b) => (b.ts || 0) - (a.ts || 0));
+}
+
+/** The org's decision gates (`<org>/gates.json`), newest first. */
+export function listGates(root, org) {
+  return readList(root, org, 'gates.json', 'gates')
+    .map((g) => ({
+      id: g.id,
+      name: g.name,
+      description: g.description,
+      roleId: g.roleId,
+      status: g.status || 'pending',
+      createdAt: g.createdAt || null,
+      resolvedBy: g.resolvedBy || null,
+      resolvedAt: g.resolvedAt || null,
+      resolution: g.resolution || null,
+    }))
+    .sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));
+}
+
+/** The org's ask_human questions. `blocking` is false only when the role said
+ *  it can carry on without an answer; pre-D4 records read as blocking. */
+export function listQuestions(root, org) {
+  return readList(root, org, 'questions.json', 'questions').map((q) => ({
+    ...q,
+    blocking: q.blocking !== false,
+  }));
+}
+
+/** Everything awaiting a human across every org in `root`. */
+export function pendingForProject(root) {
+  const base = path.join(root, '.monomind', 'orgs');
+  const out = { questions: [], approvals: [], gates: [], errors: [] };
+  let entries = [];
+  try {
+    entries = fs.readdirSync(base, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    if (!e.isDirectory() || !/^[a-z0-9][a-z0-9_-]{0,63}$/i.test(e.name)) continue;
+    const org = e.name;
+    try {
+      for (const q of listQuestions(root, org)) out.questions.push({ org, ...q });
+      for (const a of listApprovals(root, org)) out.approvals.push({ org, ...a });
+      for (const g of listGates(root, org)) out.gates.push({ org, ...g });
+    } catch (err) {
+      out.errors.push({ org, error: err.message });
+    }
+  }
+  return out;
+}
+
+export async function resolveApproval(root, org, requestId, approved) {
+  const entry = readList(root, org, 'approvals.json', 'approvals').find(
+    (a) => a.requestId === requestId,
+  );
+  if (!entry) throw new HilError(404, `approval "${requestId}" not found for org "${org}"`);
+  if (entry.approved !== null)
+    throw new HilError(409, `approval "${requestId}" already ${approvalStatus(entry)}`);
+  const live = await callDaemon(org, '/api/set-approval', {
+    org,
+    role: entry.roleId,
+    action: entry.action,
+    approved,
+    resolvedBy: DASHBOARD_RESOLVER,
+    requestId,
+  });
+  if (live) return { delivery: 'live' };
+  // Offline: re-read so a write since the lookup above isn't reverted.
+  const fresh = readList(root, org, 'approvals.json', 'approvals');
+  const item = fresh.find((a) => a.requestId === requestId);
+  if (!item || item.approved !== null)
+    throw new HilError(409, `approval "${requestId}" was resolved meanwhile`);
+  const now = Date.now();
+  Object.assign(item, { approved, ts: now, resolvedBy: DASHBOARD_RESOLVER, resolvedAt: now });
+  writeList(root, org, 'approvals.json', 'approvals', fresh);
+  return { delivery: 'recorded' };
+}
+
+export async function resolveGate(root, org, gateId, approved, resolution) {
+  const gate = readList(root, org, 'gates.json', 'gates').find((g) => g.id === gateId);
+  if (!gate) throw new HilError(404, `gate "${gateId}" not found for org "${org}"`);
+  if (gate.status !== 'pending')
+    throw new HilError(409, `gate "${gateId}" already resolved (${gate.status})`);
+  const live = await callDaemon(org, '/api/resolve-gate', {
+    org,
+    gateId,
+    approved,
+    resolution,
+    resolvedBy: DASHBOARD_RESOLVER,
+  });
+  if (live) return { delivery: 'live' };
+  const fresh = readList(root, org, 'gates.json', 'gates');
+  const idx = fresh.findIndex((g) => g.id === gateId);
+  if (idx === -1 || fresh[idx].status !== 'pending')
+    throw new HilError(409, `gate "${gateId}" was resolved meanwhile`);
+  fresh[idx] = {
+    ...fresh[idx],
+    status: approved ? 'approved' : 'rejected',
+    resolvedAt: Date.now(),
+    resolvedBy: DASHBOARD_RESOLVER,
+    ...(resolution ? { resolution } : {}),
+  };
+  writeList(root, org, 'gates.json', 'gates', fresh);
+  return { delivery: 'recorded' };
+}
+
+export async function answerQuestion(root, org, questionId, answer) {
+  const q = readList(root, org, 'questions.json', 'questions').find(
+    (x) => x.questionId === questionId,
+  );
+  if (!q) throw new HilError(404, `question "${questionId}" not found for org "${org}"`);
+  if (q.answer !== null && q.answer !== undefined)
+    throw new HilError(409, `question "${questionId}" was already answered`);
+  const live = await callDaemon(org, '/api/answer-question', {
+    org,
+    role: q.role,
+    questionId,
+    answer,
+    resolvedBy: DASHBOARD_RESOLVER,
+  });
+  if (live) return { delivery: 'live', role: q.role };
+  const fresh = readList(root, org, 'questions.json', 'questions');
+  const freshQ = fresh.find((x) => x.questionId === questionId);
+  if (freshQ && freshQ.answer !== null && freshQ.answer !== undefined)
+    throw new HilError(409, `question "${questionId}" was answered meanwhile`);
+  // Queue BEFORE marking answered (daemon.answerQuestion's rule): a failed
+  // append must leave the question pending and answerable.
+  const queued = queueMessage(root, org, {
+    fromQualified: 'human',
+    toRole: q.role,
+    subject: `answer:${questionId}`,
+    body: `question: ${q.question}\n\nanswer: ${answer}`,
+    ts: Date.now(),
+  });
+  if (!queued) throw new HilError(500, 'could not queue the answer — it was NOT recorded, retry');
+  const now = Date.now();
+  const answered = { answer, answeredAt: now, resolvedBy: DASHBOARD_RESOLVER };
+  const merged = fresh.some((x) => x.questionId === questionId)
+    ? fresh.map((x) => (x.questionId === questionId ? { ...x, ...answered } : x))
+    : [...fresh, { ...q, ...answered }];
+  writeList(root, org, 'questions.json', 'questions', merged);
+  return { delivery: 'queued', role: q.role };
+}
+
+/** Deliver `text` to `role`: live into its mailbox, else into the org's
+ *  inbox, which the daemon drains when the org next starts. */
+export async function sendHumanMessage(root, org, role, text) {
+  const live = await callDaemon(org, '/api/human-message', { org, role, text });
+  if (live) return { delivery: 'live' };
+  const queued = queueMessage(root, org, {
+    fromQualified: 'human',
+    toRole: role,
+    subject: 'message from human',
+    body: text,
+    ts: Date.now(),
+  });
+  if (!queued) throw new HilError(500, 'could not queue the message');
+  return { delivery: 'queued' };
+}
+
+/** Map a thrown error to an HTTP status + message. */
+export function hilErrorStatus(err) {
+  return { status: err instanceof HilError ? err.status : 500, error: err.message };
+}

package/dist/src/ui/org-runtime.mjs

@@ -0,0 +1,350 @@
+// What an Org Runtime v2 org is doing, for the dashboard's Runtime pane,
+// assembled from the runtime's own sources rather than the dashboard's
+// derived files:
+//   - the live daemon's /api/status (roles, task DAG) when the org runs —
+//     read with the org's AGENT credential, which authorizes no decision;
+//   - <org>/runtime.json (last run, checkpointed task DAG) when it doesn't;
+//   - <org>/<run>/bus.jsonl (per-role usage incl. cache tokens, and the
+//     evidence-gate / idle-watchdog audit trail);
+//   - <org>/idle-watchdog.json (the idle clock and its hold deadline);
+//   - <org>/history.jsonl (how each run actually ended);
+//   - the org definition, resolved through cost_tiers like session.ts does.
+import fs from 'node:fs';
+import path from 'node:path';
+// Compiled from orgrt/*.ts, like forwarder.js in routes-org.mjs.
+import { lookupOrg } from '../orgrt/broker.js';
+import { resolveRoleCostTier, validateCostTiers } from '../orgrt/cost-tier.js';
+import { readIdleStatus } from '../orgrt/idle-deadline.js';
+import { OrgDefSchema } from '../orgrt/types.js';
+
+const orgDir = (root, org) => path.join(root, '.monomind', 'orgs', org);
+
+/** Audit reasons the Runtime pane lists: the completion-evidence gate, the
+ *  idle watchdog, org_complete refusals and role failures. */
+export const RUNTIME_AUDIT_REASONS = new Set([
+  'task-evidence-refused',
+  'task-evidence-escalated',
+  'org-complete-refused',
+  'idle-nudge',
+  'idle-stop',
+  'no-progress',
+  'hold-expired',
+  'circuit-breaker-tripped',
+  'budget-exhausted',
+  'org-budget-exhausted',
+  'agent-fatal',
+  'worker-crashed',
+  'session-result-error',
+  'loadout-unresolvable',
+  'loadout-mismatch',
+]);
+const MAX_AUDIT = 60;
+
+function readJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+const zeroUsage = () => ({
+  tokens: 0,
+  tokens_in: 0,
+  tokens_out: 0,
+  cache_read: 0,
+  cache_creation: 0,
+  cost_usd: 0,
+  turns: 0,
+  // Tokens from usage events recorded before the four-way split (ADR-O001
+  // D1). Their `tokens` counted input + output only — no cache — so they add
+  // to the uncached figure and leave the billable one unknown.
+  legacy_tokens: 0,
+});
+
+// A run's bus.jsonl reaches tens of MB; parse each version once.
+const runCache = new Map();
+
+/** Per-role usage, last activity and the runtime audit trail of one run. */
+export function readRunDigest(root, org, run) {
+  const file = path.join(orgDir(root, org), run, 'bus.jsonl');
+  let st;
+  try {
+    st = fs.statSync(file);
+  } catch {
+    return null;
+  }
+  const cached = runCache.get(file);
+  if (cached && cached.size === st.size && cached.mtimeMs === st.mtimeMs) return cached.digest;
+  const usage = {};
+  const lastActivity = {};
+  const audit = [];
+  let startedAt = null;
+  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+    if (!line) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (startedAt === null && typeof e.ts === 'number') startedAt = e.ts;
+    if (e.from && typeof e.ts === 'number') lastActivity[e.from] = e.ts;
+    if (e.type === 'usage' && e.from) {
+      const u = (usage[e.from] ??= zeroUsage());
+      const d = e.data ?? {};
+      if (d.tokens_in === undefined) {
+        u.legacy_tokens += Number(d.tokens) || 0;
+        u.cost_usd += Number(d.cost_usd) || 0;
+        u.turns += 1;
+        continue;
+      }
+      u.tokens += Number(d.tokens) || 0;
+      u.tokens_in += Number(d.tokens_in) || 0;
+      u.tokens_out += Number(d.tokens_out) || 0;
+      u.cache_read += Number(d.cache_read) || 0;
+      u.cache_creation += Number(d.cache_creation) || 0;
+      u.cost_usd += Number(d.cost_usd) || 0;
+      u.turns += 1;
+    } else if (e.type === 'audit' && RUNTIME_AUDIT_REASONS.has(e.reason)) {
+      audit.push({
+        ts: e.ts,
+        reason: e.reason,
+        from: e.from ?? null,
+        msg: e.msg ?? '',
+        data: e.data ?? null,
+      });
+      if (audit.length > MAX_AUDIT) audit.shift();
+    }
+  }
+  const digest = { startedAt, usage, lastActivity, audit: audit.reverse() };
+  runCache.set(file, { size: st.size, mtimeMs: st.mtimeMs, digest });
+  return digest;
+}
+
+/** The live daemon's status for `org`, or null when no daemon hosts it. */
+async function liveStatus(org) {
+  const entry = lookupOrg(org);
+  if (!entry) return null;
+  try {
+    const res = await fetch(`${entry.url}/api/status`, {
+      headers: entry.credential ? { 'x-monomind-cred': entry.credential } : {},
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return { unreachable: `daemon answered ${res.status}` };
+    const snap = await res.json();
+    return (
+      (snap.orgs || []).find((o) => o.name === org) ?? {
+        unreachable: 'daemon does not list this org',
+      }
+    );
+  } catch (err) {
+    return { unreachable: err.message };
+  }
+}
+
+/** Last `n` history.jsonl entries, newest first, trimmed to what a run
+ *  outcome needs (`closedBy` before `outcome` — see reporting.ts). */
+export function readRecentHistory(root, org, n = 10) {
+  let raw;
+  try {
+    raw = fs.readFileSync(path.join(orgDir(root, org), 'history.jsonl'), 'utf8');
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split('\n').filter(Boolean).slice(-n).reverse()) {
+    try {
+      const h = JSON.parse(line);
+      out.push({
+        run: h.run,
+        startedAt: h.startedAt ?? null,
+        endedAt: h.endedAt ?? null,
+        durationMs: h.durationMs ?? null,
+        closedBy: h.closedBy ?? null,
+        outcome: h.outcome ?? null,
+        blocker: h.blocker ?? null,
+        blockerDetail: h.blockerDetail ?? null,
+        runnableTasksAtStop: h.runnableTasksAtStop ?? 0,
+        crashes: h.crashes ?? [],
+        totalTokens: h.totalTokens ?? 0,
+        totalCostUsd: h.totalCostUsd ?? 0,
+      });
+    } catch {
+      /* one bad line doesn't hide the rest */
+    }
+  }
+  return out;
+}
+
+/** Model and effort a role runs with, with where each came from. Mirrors
+ *  session.ts: an explicit adapter_config.model beats the tier's model; the
+ *  tier's effort applies either way. */
+export function describeRoleModel(role, def) {
+  let tier = null;
+  let tierError = null;
+  try {
+    tier = resolveRoleCostTier({ role, def }) ?? null;
+  } catch (err) {
+    tierError = err.message;
+  }
+  const explicit = role.adapter_config?.model || null;
+  return {
+    runtime: role.runtime ?? def.runtime ?? 'claude',
+    model: explicit ?? tier?.model ?? null,
+    modelSource: explicit ? 'adapter_config' : tier ? 'tier' : 'runtime default',
+    effort: tier?.effort ?? null,
+    tier: tier?.tier ?? null,
+    tierError,
+  };
+}
+
+export async function runtimeView(root, org) {
+  const raw = readJson(path.join(root, '.monomind', 'orgs', `${org}.json`));
+  if (!raw) return null;
+  const parsed = OrgDefSchema.safeParse(raw);
+  // Defaults (run_config) come from the schema; an invalid definition still
+  // renders, with the problems listed.
+  const def = parsed.success ? parsed.data : { ...raw, run_config: raw.run_config ?? {} };
+  const rc = def.run_config ?? {};
+  const runtime = readJson(path.join(orgDir(root, org), 'runtime.json'));
+  const live = await liveStatus(org);
+  const isLive = !!(live && !live.unreachable);
+  const run = (isLive ? live.run : null) ?? runtime?.run ?? null;
+  const digest = run ? readRunDigest(root, org, run) : null;
+  const liveRoles = new Map((isLive ? live.roles : []).map((r) => [r.id, r]));
+  const pendingRoles = new Set(isLive ? live.pendingRoles : []);
+
+  const roles = (def.roles || []).map((r) => {
+    const lr = liveRoles.get(r.id);
+    return {
+      id: r.id,
+      title: r.title || r.id,
+      reportsTo: r.reports_to ?? null,
+      ...describeRoleModel(r, def),
+      status: lr?.status ?? (pendingRoles.has(r.id) ? 'not started' : isLive ? 'idle' : 'stopped'),
+      usage: digest?.usage[r.id] ?? zeroUsage(),
+      lastActivity: digest?.lastActivity[r.id] ?? null,
+    };
+  });
+  const totals = roles.reduce((t, r) => {
+    for (const k of Object.keys(t)) t[k] += r.usage[k];
+    return t;
+  }, zeroUsage());
+  const basis = rc.budget_tokens_basis ?? 'uncached';
+
+  return {
+    org,
+    valid: parsed.success,
+    problems: parsed.success
+      ? []
+      : parsed.error.issues.map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`),
+    live: isLive,
+    liveError: live?.unreachable ?? null,
+    run,
+    status: isLive ? 'running' : (runtime?.status ?? 'never run'),
+    closedBy: isLive ? null : (runtime?.closedBy ?? null),
+    startedAt: digest?.startedAt ?? null,
+    updated: runtime?.updated ?? null,
+    idle: isLive && run ? readIdleStatus(root, org, run) : null,
+    settings: {
+      completion: rc.completion ?? 'boss',
+      completion_evidence: !!rc.completion_evidence,
+      max_evidence_attempts: rc.max_evidence_attempts ?? 3,
+      idle_minutes: rc.idle_minutes ?? 10,
+      session_scope: rc.session_scope ?? 'role',
+      workspace: rc.workspace ?? 'repo',
+      max_concurrent_agents: rc.max_concurrent_agents ?? 4,
+    },
+    budget: {
+      tokens: rc.budget_tokens ?? null,
+      basis,
+      // Enforcement counts cache tokens only on 'billable'. Pre-split usage
+      // (legacy_tokens) is uncached, so it leaves a billable total unknown.
+      used:
+        basis === 'billable'
+          ? totals.legacy_tokens > 0
+            ? null
+            : totals.tokens
+          : totals.tokens_in + totals.tokens_out + totals.legacy_tokens,
+    },
+    totals,
+    roles,
+    tasks: (isLive ? live.tasks : runtime?.checkpoint?.tasks) ?? [],
+    audit: digest?.audit ?? [],
+    history: readRecentHistory(root, org),
+  };
+}
+
+/** run_config keys the dashboard's Config tab may set. Everything else in the
+ *  definition is left exactly as it is on disk. */
+const EDITABLE_RUN_CONFIG = new Set([
+  'max_concurrent_agents',
+  'budget_tokens',
+  'budget_tokens_basis',
+  'idle_minutes',
+  'completion',
+  'completion_evidence',
+  'max_evidence_attempts',
+  'session_scope',
+  'workspace',
+  'memory_namespace',
+  'max_turns_per_message',
+]);
+
+export class ConfigRejected extends Error {
+  constructor(problems) {
+    super(problems.join('; '));
+    this.problems = problems;
+  }
+}
+
+/** Apply `patch` ({ goal?, schedule?, run_config?, cost_tiers_default? }) to
+ *  the org definition on disk and write it only if the result passes the same
+ *  OrgDefSchema parse (and cost-tier check) `org run` performs. A `null`
+ *  run_config value removes that key, so the runtime default applies. Returns
+ *  the definition as written. */
+export function patchOrgConfig(root, org, patch) {
+  const file = path.join(root, '.monomind', 'orgs', `${org}.json`);
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (err) {
+    throw new ConfigRejected([`cannot read ${file}: ${err.message}`]);
+  }
+  const problems = [];
+  const next = { ...raw };
+  if (patch.goal !== undefined) next.goal = String(patch.goal);
+  if (patch.schedule !== undefined) next.schedule = patch.schedule === '' ? null : patch.schedule;
+  if (patch.run_config !== undefined) {
+    const rc = { ...(raw.run_config ?? {}) };
+    for (const [k, v] of Object.entries(patch.run_config ?? {})) {
+      if (!EDITABLE_RUN_CONFIG.has(k)) {
+        problems.push(`run_config.${k} is not editable here`);
+        continue;
+      }
+      if (v === null) delete rc[k];
+      else rc[k] = v;
+    }
+    next.run_config = rc;
+  }
+  if (patch.cost_tiers_default !== undefined) {
+    const ct = { ...(raw.cost_tiers ?? {}) };
+    if (patch.cost_tiers_default) ct.default = String(patch.cost_tiers_default);
+    else delete ct.default;
+    if (Object.keys(ct).length) next.cost_tiers = ct;
+    else delete next.cost_tiers;
+  }
+  if (problems.length) throw new ConfigRejected(problems);
+  const parsed = OrgDefSchema.safeParse(next);
+  if (!parsed.success)
+    throw new ConfigRejected(
+      parsed.error.issues.map((i) => `${i.path.join('.') || '(root)'}: ${i.message}`),
+    );
+  const tierProblems = validateCostTiers(parsed.data);
+  if (tierProblems.length) throw new ConfigRejected(tierProblems);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`);
+  fs.renameSync(tmp, file);
+  return next;
+}

package/dist/src/ui/orgs.html

@@ -1827,6 +1827,9 @@ async function loadRunHistory() {
               ? `<span style="color:${outcomeColor(h.outcome.status)}">${esc(h.outcome.status.toUpperCase())}</span>
                  <span style="color:var(--muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(h.outcome.summary || '')}</span>`
               : `<span style="color:var(--dim)">NO OUTCOME</span>`}
+            ${h.blocker ? `<span style="color:var(--amber, #d90)">blocker: ${esc(h.blocker)}</span>` : ''}
+            <span style="color:var(--dim);white-space:nowrap" title="How the run actually ended (history closedBy)">${esc(h.closedBy ? `closed by ${h.closedBy}` : 'stopped manually')}</span>
+            ${Number(h.runnableTasksAtStop) > 0 ? `<span style="color:var(--amber, #d90);white-space:nowrap">${Number(h.runnableTasksAtStop)} tasks open</span>` : ''}
             ${Array.isArray(h.crashes) && h.crashes.length ? `<span style="color:var(--red)">✗ ${Number(h.crashes.length)} crash</span>` : ''}
           </div>`).join('')}
       </div>`;
@@ -2111,13 +2114,21 @@ async function sendChatMessage() {
   btn.disabled = true;
   input.value = '';
   input.style.height = '';
+  let error = null;
   try {
-    await fetch(`/api/orgs/${encodeURIComponent(selectedOrg)}/chat`, {
+    const res = await fetch(`/api/orgs/${encodeURIComponent(selectedOrg)}/chat`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ text }),
     });
-  } catch(_) {}
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok || !data.ok) error = data.error || `HTTP ${res.status}`;
+  } catch (e) { error = e.message; }
+  if (error) {
+    // Keep what was typed; say why it did not go out.
+    input.value = text;
+    alert(`Not delivered: ${error}`);
+  }
   btn.disabled = false;
   input.focus();
 }
@@ -2312,13 +2323,13 @@ function connectSSE() {
           renderActivity();
         }
         // Reload org list if start/stop event
-        if (ev.type === 'org:start' || ev.type === 'org:stop') {
+        if (ev.type === 'org:start' || ev.type === 'org:stop' || ev.type === 'org:complete') {
           setTimeout(loadOrgs, 400);
         }
         // Update live strip for selected org on chart tab
         if (name === selectedOrg && currentTab === 'chart') {
           if (ev.type === 'org:start') orgRunStartMs = Date.now();
-          if (ev.type === 'org:stop') orgRunStartMs = null;
+          if (ev.type === 'org:stop' || ev.type === 'org:complete') orgRunStartMs = null;
           appendLiveFeedRow(ev, true);
           updateLiveStrip();
         }