axstack 0.54.0 → 0.56.0

package/skills/axstack/scripts/fleet-receipt.js

@@ -0,0 +1,130 @@
+// Saved evidence validator. A pass binds supplied facts; it cannot authenticate them.
+import { canonical, record, text, time } from './fleet-config.js';
+
+function options(value) {
+  if (!Array.isArray(value)) return record(value) ? value : null;
+  if (value.some((v) => !text(v?.id) || !['string', 'boolean'].includes(typeof v.value))
+    || new Set(value.map((v) => v.id)).size !== value.length) return null;
+  return Object.fromEntries(value.map((v) => [v.id, v.value]));
+}
+const same = (a, b) => a !== undefined && b !== undefined && canonical(a) === canonical(b);
+const absolute = (path) => text(path) && path.startsWith('/') && !path.split('/').some((p) => p === '..' || p === '.');
+
+export function inspectFleetReceipt(receipt, expected) {
+  const terms = [];
+  const term = (code, pass, observed, missing = observed === undefined || observed === null) => {
+    terms.push({ code, state: pass ? 'pass' : missing ? 'unknown' : 'fail', evidence: observed ?? null });
+  };
+  const r = receipt ?? {};
+  term('receipt-version', r.schemaVersion === 1, r.schemaVersion);
+  const a = expected.attempt;
+  const s = expected.recommendation.selected;
+  const request = expected.recommendation.request;
+  term('receipt-origin', text(a?.origin?.threadId) && a?.origin?.environmentId === expected.recommendation.originEnvironmentId
+    && same(r.attempt?.origin, a?.origin), r.attempt?.origin,
+  !text(a?.origin?.threadId) || r.attempt?.origin == null);
+  term('receipt-attempt', text(a?.key) && text(a?.clientRequestId) && text(a?.origin?.taskId)
+    && same(r.attempt, a), r.attempt);
+  term('receipt-recommendation', r.recommendationJSON === expected.recommendationJSON, r.recommendationJSON);
+  term('receipt-config', r.configDigest === expected.recommendation.configDigest, r.configDigest);
+  const status = r.status?.value;
+  const submitted = r.submission;
+  const thread = r.thread?.value?.thread;
+  const remote = s.environmentId !== expected.recommendation.originEnvironmentId;
+  const child = (v) => remote ? v?.remoteChild?.threadId : v?.childThreadId;
+  const env = (v) => remote ? v?.remoteChild?.environmentId : a?.origin?.environmentId;
+  term('receipt-destination', env(status) === s.environmentId && env(submitted) === s.environmentId
+    && text(child(status)) && child(status) === child(submitted)
+    && r.thread?.environmentId === s.environmentId && thread?.threadId === child(status),
+  { submitted: submitted?.remoteChild ?? submitted?.childThreadId,
+    status: status?.remoteChild ?? status?.childThreadId, thread: r.thread?.environmentId });
+  term('receipt-title', text(a?.title) && thread?.title === a.title, thread?.title);
+  term('receipt-project', thread?.projectId === s.projectId, thread?.projectId);
+  for (const [name, tool, environmentId, args] of [
+    ['status', 'task_status', a?.origin?.environmentId, { taskId: a?.origin?.taskId }],
+    ['thread', 't3_thread_read', s.environmentId, { threadId: child(status) }],
+    ['terminal', 't3_thread_wait', s.environmentId, { threadId: child(status), runId: thread?.latestRunId }],
+  ]) {
+    const read = r[name];
+    term('receipt-observation', read?.tool === tool && read?.environmentId === environmentId
+      && same(read?.args, args) && time(read?.observedAt) && read.observedAt <= expected.now
+      && text(read?.evidence), read);
+  }
+  term('receipt-origin', status?.taskId === a?.origin?.taskId && submitted?.taskId === a?.origin?.taskId,
+    status?.taskId);
+  const target = r.requested?.target;
+  term('receipt-requested', target?.environmentId === s.environmentId && target?.projectId === s.projectId
+    && target?.providerInstanceId === request.providerInstanceId && target?.model === request.model
+    && same(options(target?.options), request.options) && r.requested?.runtimeMode === request.runtimeMode,
+  r.requested);
+  term('receipt-effective', status?.providerInstanceId === request.providerInstanceId
+    && status?.model === request.model && thread?.providerInstanceId === request.providerInstanceId
+    && thread?.model === request.model && same(options(status?.options), request.options)
+    && thread?.runtimeMode === request.runtimeMode, { provider: status?.providerInstanceId,
+    model: status?.model, options: status?.options ?? null, runtimeMode: thread?.runtimeMode },
+  status?.options == null || thread?.runtimeMode == null);
+  const terminal = r.terminal?.value;
+  term('receipt-terminal', status?.status === 'completed' && status?.latestTerminalStatus === 'completed'
+    && status?.workState === 'result_available' && status?.hasPendingChildRuns === false
+    && ['completed', 'idle'].includes(thread?.status) && thread?.activeRunId === null
+    && terminal?.status === 'completed' && terminal?.timedOut === false, { status, terminal },
+  status?.status == null || status?.workState == null || status?.hasPendingChildRuns == null
+    || status?.latestTerminalStatus == null || terminal?.status == null || terminal?.timedOut == null
+    || thread?.activeRunId === undefined);
+  term('receipt-question', status?.hasPendingQuestion === false && status?.pendingApproval === null
+    && thread?.pendingRequestCount === 0, { hasPendingQuestion: status?.hasPendingQuestion,
+    pendingApproval: status?.pendingApproval, pendingRequestCount: thread?.pendingRequestCount },
+  status?.hasPendingQuestion == null || status?.pendingApproval === undefined || thread?.pendingRequestCount == null);
+  const questions = r.questions;
+  term('receipt-question', questions?.tool === 't3_pending_request'
+    && questions?.environmentId === s.environmentId
+    && same(questions?.args, { action: 'list', threadId: child(status) })
+    && time(questions?.observedAt) && questions.observedAt <= expected.now
+    && text(questions?.evidence) && Array.isArray(questions?.value?.requests)
+    && questions.value.requests.length === 0, questions,
+  questions == null || questions.value?.requests === undefined);
+  const current = thread?.latestRunId;
+  const runs = r.thread?.value?.recentRuns;
+  const latest = Array.isArray(runs) ? runs.find((v) => v.runId === current) : null;
+  term('receipt-run', text(current) && status?.latestTerminalRunId === current
+    && terminal?.threadId === child(status) && terminal?.runId === current
+    && (!terminal?.resultRun || (terminal.resultRun.runId === current && terminal.resultRun.status === 'completed'))
+    && (!remote || (r.remoteChild?.environmentId === s.environmentId
+      && r.remoteChild?.threadId === child(status) && r.remoteChild?.runId === current))
+    && latest?.status === 'completed' && Number.isSafeInteger(latest?.ordinal)
+    && runs.every((v) => Number.isSafeInteger(v.ordinal) && v.ordinal <= latest.ordinal),
+  { current, originTerminal: status?.latestTerminalRunId, terminal, runs },
+  !current || !status?.latestTerminalRunId || !terminal?.runId || !Array.isArray(runs)
+    || (remote && !r.remoteChild?.runId));
+  const marker = `AXSTACK-DONE key=${a?.key} head=${a?.candidate} report=${r.evidence?.path}`;
+  const finalMarker = (value) => {
+    if (typeof value !== 'string') return null;
+    const lines = value.trim().split('\n');
+    const markers = lines.filter((line) => line.startsWith('AXSTACK-'));
+    if (markers.length !== 1) return null;
+    const trailer = lines.slice(lines.indexOf(markers[0]) + 1);
+    return trailer.length === 0 || (trailer.length === 1
+      && /^PR https?:\/\/\S+, head [a-f0-9]{7,40}, checks and reviews .+$/.test(trailer[0]))
+      ? markers[0] : null;
+  };
+  const items = r.thread?.value?.items;
+  const final = Array.isArray(items) ? items.filter((v) => v.runId === current && v.createdBy === 'agent').at(-1) : null;
+  term('receipt-marker', /^[a-f0-9]{40}$/.test(a?.candidate ?? '')
+    && finalMarker(status?.latestTerminalSummary) === marker && finalMarker(final?.text) === marker,
+  { origin: status?.latestTerminalSummary, destination: final?.text });
+  term('receipt-host-path', r.evidence?.hostId === s.hostId && r.evidence?.environmentId === s.environmentId
+    && absolute(r.evidence?.path) && finalMarker(status?.latestTerminalSummary)?.endsWith(` report=${r.evidence.path}`), r.evidence);
+  if (a?.title?.startsWith('Reviewer: ')) {
+    term('receipt-isolation', r.requested?.isolation === 'worktree', r.requested?.isolation);
+  }
+  if (a?.title?.startsWith('Reviewer: ') || r.checkout != null || thread?.worktreePath != null || r.requested?.isolation === 'worktree') {
+    const c = r.checkout;
+    term('receipt-checkout', c?.hostId === s.hostId && c?.environmentId === s.environmentId
+      && absolute(c?.path) && c.path === thread?.worktreePath
+      && /^[a-f0-9]{40}$/.test(a?.base ?? '') && c?.base === a.base && c?.candidate === a.candidate
+      && c?.readback?.hostId === s.hostId && c?.readback?.environmentId === s.environmentId
+      && c?.readback?.path === c.path && c?.readback?.base === a.base && c?.readback?.candidate === a.candidate
+      && text(c?.readback?.evidence), c);
+  }
+  return terms;
+}

package/skills/axstack/scripts/fleet-route-cli.js

@@ -0,0 +1,78 @@
+import { readFileSync } from 'node:fs';
+import { sampleMain, sampleHelp } from './fleet-sample-cli.js';
+import { recommend, parseFleetConfig } from './fleet-route.js';
+
+const help = `Usage: bun fleet-route.js recommend --input <snapshot.json> --now <epoch-ms> [--json]
+  [--task <name>] [--config <fleet-routing.json>] [--config-digest <sha256>]
+
+--input          Saved schema-1 facts; no collection or dispatch
+--now            Required nonnegative integer evaluation time; no ambient clock
+--task           Override the saved request's task preference
+--config         Reviewed account-local config (default: ~/.config/haoshoku/fleet-routing.json)
+--config-digest  Run-pinned SHA-256; otherwise required in saved input.configDigest
+--json           Emit complete recommendation JSON; errors are JSON on stderr
+--help           Show this interface
+
+Reads only the supplied input and config. Writes stdout/stderr only.
+No network, authentication, dispatch, config changes or retained state.
+Required session capabilities must be proven on the actual destination session;
+an origin catalog or transferred credentials cannot establish them.
+Exclusions with reasons are supplied in input.exclusions.hosts/routes.
+Use sample or sample-recommend for bounded collection.
+Exit codes: 0 recommendation/help, 1 input/config error, 2 no executable route.
+`;
+
+const fail = (code) => { throw new Error(code); };
+function readInput(path) {
+  let value;
+  try { value = readFileSync(path, 'utf8'); } catch { fail('missing-input'); }
+  try { return JSON.parse(value); } catch { fail('input-json'); }
+}
+
+function defaultConfigPath() {
+  return process.env.HOME ? `${process.env.HOME}/.config/haoshoku/fleet-routing.json` : null;
+}
+
+export async function main(argv) {
+  try {
+    if (argv.length === 1 && argv[0] === '--help') {
+      process.stdout.write(help + sampleHelp);
+      return 0;
+    }
+    if (['sample', 'sample-recommend'].includes(argv[0])) return await sampleMain(argv, defaultConfigPath());
+    if (argv[0] !== 'recommend') fail('unexpected-command');
+    const args = {};
+    for (let i = 1; i < argv.length; i++) {
+      const flag = argv[i];
+      if (!['--input', '--now', '--task', '--config', '--config-digest', '--json'].includes(flag)) fail('unexpected-argument');
+      if (Object.hasOwn(args, flag)) fail('duplicate-argument');
+      if (flag === '--json') { args[flag] = true; continue; }
+      const value = argv[++i];
+      if (!value?.trim() || value.startsWith('--')) fail('missing-argument');
+      args[flag] = value;
+    }
+    if (!args['--input'] || !args['--now']) fail('missing-argument');
+    if (!/^\d+$/.test(args['--now'])) fail('evaluation-time');
+    const now = Number(args['--now']);
+    const input = readInput(args['--input']);
+    if (!input || typeof input !== 'object' || Array.isArray(input) || input.schemaVersion !== 1) fail('schema-version: input');
+    let configText;
+    const configPath = args['--config'] ?? defaultConfigPath();
+    try {
+      if (!configPath) fail('missing-config');
+      configText = readFileSync(configPath, 'utf8');
+    } catch { fail('missing-config'); }
+    const configDigest = args['--config-digest'] ?? input.configDigest;
+    parseFleetConfig(configText, configDigest);
+    if (input.configDigest !== undefined && input.configDigest !== configDigest) fail('config-digest-mismatch');
+    if (input.configText !== undefined && input.configText !== configText) fail('config-snapshot-mismatch');
+    const result = recommend({ ...input, configText, configDigest,
+      request: args['--task'] ? { ...input.request, task: args['--task'] } : input.request }, now);
+    process.stdout.write(args['--json'] ? `${JSON.stringify(result)}\n`
+      : `${result.stage}: ${result.selected?.hostId ?? 'no host'} (${result.reason})\n`);
+    return result.selected ? 0 : 2;
+  } catch (error) {
+    process.stderr.write(`${JSON.stringify({ error: { code: error.message.split(':')[0], message: error.message } })}\n`);
+    return 1;
+  }
+}

package/skills/axstack/scripts/fleet-route.js

@@ -0,0 +1,86 @@
+// Pure supplied-facts API. No clock, filesystem, networking or dispatch.
+import { parseFleetConfig, validateInput } from './fleet-config.js';
+import { assignmentCounts, routeReasons, telemetry } from './fleet-facts.js';
+export { parseFleetConfig } from './fleet-config.js';
+
+export function recommend(input, now) {
+  validateInput(input, now);
+  const config = parseFleetConfig(input.configText, input.configDigest);
+  const counts = assignmentCounts(input, config.hosts, now);
+  const preference = Object.hasOwn(config.taskOrders, input.request.task)
+    ? config.taskOrders[input.request.task] : config.defaultOrder;
+  const eligible = [];
+  const excluded = [];
+  for (const hostId of preference) {
+    const host = config.hosts.find((h) => h.id === hostId);
+    const destination = input.destinations.find((d) => d.environmentId === host.environmentId);
+    const routes = config.routes.filter((r) => r.environmentId === host.environmentId
+      && r.originEnvironmentId === input.origin.environmentId);
+    let accepted = null;
+    for (const route of routes) {
+      const facts = input.routeFacts.find((f) => f.routeId === route.id);
+      const reasons = routeReasons(route, host, destination, facts, input, now);
+      if (reasons.length) {
+        excluded.push({ hostId, environmentId: host.environmentId, routeId: route.id, reasons,
+          exclusion: (Object.hasOwn(input.exclusions.hosts, hostId) ? input.exclusions.hosts[hostId] : null)
+            ?? (Object.hasOwn(input.exclusions.routes, route.id) ? input.exclusions.routes[route.id] : null),
+          evidence: { configuredRoute: route.evidence ?? null, observedRoute: facts?.evidence ?? null,
+            destination: destination?.evidence ?? null, destinationSnapshotId: destination?.snapshotId ?? null,
+            configuredCapabilities: host.capabilities, observedCapabilities: destination?.capabilities ?? null } });
+      } else if (!accepted) {
+        accepted = { hostId, environmentId: host.environmentId, projectId: destination.project.id,
+          repositoryId: destination.project.repositoryId, routeId: route.id, routeKind: route.kind,
+          destinationSnapshotId: destination.snapshotId, destinationObservedAt: destination.observedAt,
+          ...(destination.capabilitiesDigest !== undefined
+            ? { destinationCapabilitiesDigest: destination.capabilitiesDigest } : {}),
+          destinationEvidence: destination.evidence, routeEvidence: facts.evidence, versions: destination.versions,
+          execution: destination.execution, capabilities: destination.capabilities,
+          fallbackLimitBp: host.fallbackLimitBp, assignmentCount: counts.byEnvironment[host.environmentId],
+          telemetry: telemetry(input.telemetry.find((s) => s.environmentId === host.environmentId), now) };
+      }
+    }
+    if (accepted) eligible.push(accepted);
+    if (!routes.length) excluded.push({ hostId, environmentId: host.environmentId, routeId: null, reasons: ['route-missing'], exclusion: null });
+  }
+  const pool = eligible.filter((h) => config.pool.includes(h.hostId));
+  const measured = (h) => h.telemetry.status === 'measured';
+  const rank = (h) => preference.indexOf(h.hostId);
+  const byLoad = (a, b) => a.telemetry.loadBp - b.telemetry.loadBp || rank(a) - rank(b);
+  const rankingCounts = counts.pendingLowerBound ?? counts.byEnvironment;
+  const under = pool.filter((h) => measured(h) && h.telemetry.loadBp <= config.balanceLimitBp);
+  let stage; let reason; let selected = null;
+  if (!eligible.length) { stage = 'no-route'; reason = 'no-executable-route'; }
+  else if (under.length) {
+    stage = 'balance'; reason = 'pool-under-limit';
+    selected = under.sort((a, b) => rankingCounts[a.environmentId] - rankingCounts[b.environmentId] || byLoad(a, b))[0];
+  } else if (pool.length && pool.every((h) => !measured(h))) {
+    stage = 'pool-unknown'; reason = 'pool-all-unknown'; selected = pool[0];
+  } else {
+    stage = 'fallback';
+    selected = eligible.find((h) => measured(h) && h.telemetry.loadBp <= h.fallbackLimitBp);
+    if (selected) reason = 'first-within-limit';
+    else {
+      const observed = eligible.filter(measured).sort(byLoad);
+      selected = observed[0] ?? eligible[0];
+      reason = observed.length ? 'least-loaded-over-limit' : 'all-telemetry-unknown';
+    }
+  }
+  const flags = {
+    countsUnknown: counts.inventoryStatus === 'unknown', poolEmpty: pool.length === 0,
+    poolPartlyUnknown: pool.some(measured) && pool.some((h) => !measured(h)),
+    telemetryUnknown: eligible.some((h) => !measured(h)),
+    overloaded: selected ? measured(selected) && selected.telemetry.loadBp > selected.fallbackLimitBp : false,
+    localAuthorOnly: input.request.role === 'author' && eligible.length > 0
+      && eligible.every((h) => h.environmentId === input.origin.environmentId),
+  };
+  // Copy supplied nested facts so callers cannot mutate input through the result.
+  return structuredClone({ schemaVersion: 1, configDigest: input.configDigest, evaluatedAt: now,
+    originEnvironmentId: input.origin.environmentId, request: input.request,
+    stage, reason: flags.localAuthorOnly ? 'author-local-only' : reason, decisionReason: reason,
+    selected, flags, counts, eligible, excluded });
+}
+
+if (import.meta.main) {
+  const { main } = await import('./fleet-route-cli.js');
+  process.exitCode = await main(process.argv.slice(2));
+}

package/skills/axstack/scripts/fleet-sample-cli.js

@@ -0,0 +1,81 @@
+import { readFileSync } from 'node:fs';
+import { parseFleetConfig, recommend } from './fleet-route.js';
+import { sampleFleet } from './fleet-sample.js';
+import { sampleOptions, validateManifest } from './fleet-sample-manifest.js';
+export const sampleHelp = `
+Usage: bun fleet-route.js sample --fleet <manifest.json> --config-digest <sha256> [--config <path>] [--json]
+       bun fleet-route.js sample-recommend --fleet <manifest.json> --input <snapshot.json>
+         --config-digest <sha256> [--config <path>] [--json]
+--fleet        Schema-1 manifest; exact host/environment joins; local or SSH transport
+--interval-ms  Integer 5000..60000; default 5000; minimum gap between two reads
+--timeout-ms   Per-host whole-collection deadline; default 10000; interval+1000..120000
+--config       Same reviewed config/default path as recommend; explicit digest required
+--input        sample-recommend only: C1 access/project/capability/assignment facts
+--json         Full sample report or {input,evaluatedAt,recommendation} replay envelope
+
+Sample commands read Linux /proc/stat and /proc/meminfo locally or through bounded,
+noninteractive SSH argv to validated MagicDNS short names with existing identities.
+They use collector receipt time, collect hosts concurrently, and write stdout/stderr only.
+Window duration brackets transport plus reads and interval; it is not native history.
+Unknown telemetry never grants a route. No dispatch, config mutation or retained state.
+Exit codes: 0 sample/recommendation, 1 input/config error, 2 no executable route.
+`;
+const fail = (code) => { throw Error(code); };
+function read(path, name, json = true) {
+  let text;
+  try { text = readFileSync(path, 'utf8'); } catch { fail(`missing-${name}`); }
+  if (!json) return text;
+  try { return JSON.parse(text); } catch { fail(`${name}-json`); }
+}
+export async function sampleMain(argv, defaultConfigPath) {
+  const command = argv[0]; const args = {};
+  const flags = ['--fleet', '--config', '--config-digest', '--interval-ms', '--timeout-ms', '--json',
+    ...(command === 'sample-recommend' ? ['--input', '--task'] : [])];
+  for (let i = 1; i < argv.length; i++) {
+    const flag = argv[i];
+    if (!flags.includes(flag)) fail('unexpected-argument');
+    if (Object.hasOwn(args, flag)) fail('duplicate-argument');
+    if (flag === '--json') { args[flag] = true; continue; }
+    const value = argv[++i];
+    if (!value?.trim() || value.startsWith('--')) fail('missing-argument');
+    args[flag] = value;
+  }
+  if (!args['--fleet'] || (command === 'sample-recommend' && !args['--input'])) fail('missing-argument');
+  const numeric = (name, fallback, reason) => {
+    if (args[name] === undefined) return fallback;
+    if (!/^\d+$/.test(args[name])) fail(reason);
+    return Number(args[name]);
+  };
+  const options = sampleOptions({ intervalMs: numeric('--interval-ms', 5000, 'sample-interval'),
+    timeoutMs: numeric('--timeout-ms', 10000, 'sample-timeout') });
+  const configPath = args['--config'] ?? defaultConfigPath;
+  const configText = read(configPath, 'config', false);
+  const configDigest = args['--config-digest'];
+  const config = parseFleetConfig(configText, configDigest);
+  const manifest = validateManifest(read(args['--fleet'], 'manifest'), config.hosts);
+  let input;
+  if (command === 'sample-recommend') {
+    input = read(args['--input'], 'input');
+    if (input?.configDigest !== undefined && input.configDigest !== configDigest) fail('config-digest-mismatch');
+    if (input?.configText !== undefined && input.configText !== configText) fail('config-snapshot-mismatch');
+    input = { ...input, configText, configDigest, request: args['--task']
+      ? { ...input.request, task: args['--task'] } : input?.request };
+    recommend(input, Date.now()); // Validate supplied security facts before any network read.
+  }
+  const controller = new AbortController();
+  const cancel = () => controller.abort();
+  process.once('SIGINT', cancel); process.once('SIGTERM', cancel);
+  let samples;
+  try { samples = await sampleFleet(manifest, config.hosts, options, { signal: controller.signal }); }
+  finally { process.removeListener('SIGINT', cancel); process.removeListener('SIGTERM', cancel); }
+  const evaluatedAt = Date.now();
+  if (command === 'sample') {
+    process.stdout.write(`${JSON.stringify({ ...samples, telemetry: samples.telemetry.map((s) => ({ ...s, ageMs: evaluatedAt - s.receivedAt })),
+      configDigest, collectedAt: evaluatedAt })}\n`);
+    return 0;
+  }
+  input = { ...input, telemetry: samples.telemetry };
+  const recommendation = recommend(input, evaluatedAt);
+  process.stdout.write(`${JSON.stringify({ schemaVersion: 1, input, evaluatedAt, recommendation })}\n`);
+  return recommendation.selected ? 0 : 2;
+}

package/skills/axstack/scripts/fleet-sample-io.js

@@ -0,0 +1,59 @@
+import { readFile } from 'node:fs/promises';
+export const PROC_COMMAND = "cat /proc/stat && printf '\\n---AXSTACK-MEM---\\n' && cat /proc/meminfo";
+export function sshArgv(host) {
+  return ['ssh', '-T', '-o', 'BatchMode=yes', '-o', 'StrictHostKeyChecking=yes', '-o', 'IdentitiesOnly=yes',
+    '-o', 'ConnectTimeout=3', '-o', 'ConnectionAttempts=1', '-o', 'ServerAliveInterval=2',
+    '-o', 'ServerAliveCountMax=1', '-o', 'ControlMaster=no', '-o', 'ControlPath=none',
+    '-o', 'ClearAllForwardings=yes', '-o', 'PermitLocalCommand=no',
+    ...(host.user ? ['-l', host.user] : []), '--', host.destination, PROC_COMMAND];
+}
+export function wait(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const cancel = () => { clearTimeout(timer); signal.removeEventListener('abort', cancel); reject(signal.reason); };
+    const timer = setTimeout(() => { signal.removeEventListener('abort', cancel); resolve(); }, ms);
+    signal.addEventListener('abort', cancel, { once: true });
+    if (signal.aborted) cancel();
+  });
+}
+async function limited(stream, signal) {
+  const reader = stream.getReader(); const chunks = []; let size = 0;
+  const cancel = () => { void reader.cancel(); };
+  signal.addEventListener('abort', cancel, { once: true });
+  try {
+    while (true) {
+      if (signal.aborted) throw signal.reason;
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > 65536) throw Error('malformed');
+      chunks.push(value);
+    }
+    return new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
+  } finally {
+    signal.removeEventListener('abort', cancel);
+    await reader.cancel();
+    reader.releaseLock();
+  }
+}
+export async function readProc(host, signal, spawn = Bun.spawn) {
+  if (host.transport === 'local') {
+    const stat = await readFile('/proc/stat', { encoding: 'utf8', signal });
+    const mem = await readFile('/proc/meminfo', { encoding: 'utf8', signal });
+    return `${stat}\n---AXSTACK-MEM---\n${mem}`;
+  }
+  const child = spawn(sshArgv(host), { stdin: 'ignore', stdout: 'pipe', stderr: 'ignore' });
+  const cancel = () => child.kill('SIGKILL');
+  signal.addEventListener('abort', cancel, { once: true });
+  try {
+    if (signal.aborted) { cancel(); throw signal.reason; }
+    const output = await limited(child.stdout, signal);
+    const code = await child.exited;
+    if (signal.aborted) throw signal.reason;
+    if (code !== 0) throw Error('failed');
+    return output;
+  } finally {
+    signal.removeEventListener('abort', cancel);
+    child.kill('SIGKILL');
+    await child.exited;
+  }
+}

package/skills/axstack/scripts/fleet-sample-manifest.js

@@ -0,0 +1,34 @@
+import { record } from './fleet-config.js';
+const fail = (reason) => { throw Error(reason); };
+const keys = (obj, allowed) => record(obj) && Object.keys(obj).every((k) => allowed.includes(k));
+export function validateManifest(manifest, hosts) {
+  if (manifest?.schemaVersion !== 1) fail('schema-version: manifest');
+  if (!keys(manifest, ['schemaVersion', 'hosts']) || !Array.isArray(manifest.hosts)
+    || !manifest.hosts.length || manifest.hosts.length > 64) fail('manifest-schema');
+  const ids = new Set(); const destinations = new Set(); let local = false;
+  for (const h of manifest.hosts) {
+    if (!keys(h, ['hostId', 'environmentId', 'transport', 'destination', 'user'])) fail('manifest-schema');
+    if (!hosts.some((c) => c.id === h.hostId && c.environmentId === h.environmentId)) fail('manifest-host');
+    if (ids.has(h.hostId)) fail('manifest-duplicate');
+    ids.add(h.hostId);
+    if (!['local', 'ssh'].includes(h.transport)) fail('manifest-transport');
+    if (h.transport === 'local') {
+      if (h.destination !== undefined || h.user !== undefined) fail('manifest-schema');
+      if (local) fail('manifest-duplicate');
+      local = true;
+    } else {
+      // MagicDNS short names only. SSH aliases, IPs, ports and shell syntax are rejected.
+      if (typeof h.destination !== 'string' || !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(h.destination)
+        || /^\d+$/.test(h.destination)) fail('manifest-destination');
+      if (h.user !== undefined && (typeof h.user !== 'string' || !/^[a-z_][a-z0-9_-]{0,31}$/.test(h.user))) fail('manifest-user');
+      if (destinations.has(h.destination)) fail('manifest-duplicate');
+      destinations.add(h.destination);
+    }
+  }
+  return manifest;
+}
+export function sampleOptions({ intervalMs = 5000, timeoutMs = 10000 } = {}) {
+  if (!Number.isSafeInteger(intervalMs) || intervalMs < 5000 || intervalMs > 60000) fail('sample-interval');
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < intervalMs + 1000 || timeoutMs > 120000) fail('sample-timeout');
+  return { intervalMs, timeoutMs };
+}

package/skills/axstack/scripts/fleet-sample.js

@@ -0,0 +1,48 @@
+import { parseProc, pressure } from './fleet-proc.js';
+import { validateManifest, sampleOptions } from './fleet-sample-manifest.js';
+import { readProc, wait } from './fleet-sample-io.js';
+export { parseProc, pressure, validateManifest };
+
+// Read functions and clocks are injectable for deterministic offline verification.
+export async function sampleFleet(manifest, hosts, options, dependencies = {}) {
+  validateManifest(manifest, hosts);
+  const { intervalMs, timeoutMs } = sampleOptions(options);
+  const { clock = Date.now, monotonic = () => performance.now(), read = readProc, wait: pause = wait,
+    signal } = dependencies;
+  const telemetry = await Promise.all(manifest.hosts.map(async (host) => {
+    const controller = new AbortController();
+    const cancel = () => controller.abort(Error('cancelled'));
+    signal?.addEventListener('abort', cancel, { once: true });
+    if (signal?.aborted) cancel();
+    const timer = setTimeout(() => controller.abort(Error('timeout')), timeoutMs);
+    const windowStartedAt = clock(); const started = monotonic();
+    const source = host.transport === 'local' ? 'linux-proc-local' : 'linux-proc-ssh';
+    const provenance = { hostId: host.hostId, environmentId: host.environmentId, scope: 'whole-host', source,
+      intervalMs, timeoutMs, windowStartedAt, windowKind: 'collector-bracket' };
+    const check = () => { if (controller.signal.aborted) throw controller.signal.reason; };
+    try {
+      check();
+      const first = parseProc(await read(host, controller.signal));
+      check();
+      await pause(intervalMs, controller.signal);
+      check();
+      const last = parseProc(await read(host, controller.signal));
+      check();
+      const windowEndedAt = clock(); const durationMs = Math.floor(monotonic() - started);
+      if (durationMs >= timeoutMs) throw Error('timeout');
+      if (durationMs < intervalMs || windowEndedAt < windowStartedAt
+        || windowEndedAt - windowStartedAt < durationMs
+        || windowEndedAt - windowStartedAt > durationMs + 1000) throw Error('collector-clock');
+      return { ...provenance, status: 'ok', ...pressure(first, last), durationMs,
+        windowEndedAt, receivedAt: windowEndedAt };
+    } catch (error) {
+      const reason = controller.signal.aborted ? controller.signal.reason?.message : error.message;
+      return { ...provenance, status: ['timeout', 'cancelled', 'malformed', 'inconsistent-counters', 'collector-clock']
+        .includes(reason) ? reason : 'failed', durationMs: Math.max(0, Math.floor(monotonic() - started)), receivedAt: clock() };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', cancel);
+    }
+  }));
+  return { schemaVersion: 1, telemetry };
+}

package/skills/axstack/scripts/resolve-models.js

@@ -3,6 +3,7 @@ import { readFileSync } from 'node:fs';
 const bindings = { codex: 'codex', claude: 'claudeAgent', grok: 'grok' };
 const effortIds = { codex: 'reasoningEffort', claude: 'effort', grok: 'reasoningEffort' };
 const nonempty = (value) => typeof value === 'string' && value.trim().length > 0;
+const optionValues = (option) => option.values ?? option.options?.map((value) => value.id);
 
 function argumentsFrom(args) {
   const options = { excluded: [] };
@@ -37,9 +38,11 @@ function providerFrom(catalog, provider) {
   }
   const instance = matches[0];
   if (!Array.isArray(instance.models) || instance.models.some((model) =>
-    !model || !nonempty(model.id) || !Array.isArray(model.options) || model.options.some((option) =>
+    !model || !nonempty(model.id) || !Array.isArray(model.options ?? []) || (model.options ?? []).some((option) =>
       !option || !nonempty(option.id) || (option.options !== undefined &&
-        (!Array.isArray(option.options) || option.options.some((value) => !value || !nonempty(value.id))))))) {
+        (!Array.isArray(option.options) || option.options.some((value) => !value || !nonempty(value.id))))
+      || (option.values !== undefined && (!Array.isArray(option.values)
+        || option.values.some((value) => typeof value !== 'boolean' && !nonempty(value))))))) {
     throw new Error('malformed capabilities models or options');
   }
   return instance;
@@ -58,6 +61,7 @@ function modelFrom(models, { provider, model: pin, class: modelClass, excluded }
     }
     const model = models[0];
     if (!model || excluded.includes(model.id)) throw new Error('missing first listed model');
+    if (!model.id.startsWith('grok-')) throw new Error(`first listed model ${model.id} is not grok-family`);
     return model;
   }
   if (!['codex', 'claude'].includes(provider) || !/^[a-z]+$/.test(modelClass)) {
@@ -90,8 +94,8 @@ try {
   if ((options.class === 'terra' || /^gpt-\d+(?:\.\d+)*-terra$/.test(model.id)) && effort !== 'high') {
     throw new Error('Terra requires exactly high effort');
   }
-  const effortOptions = model.options.filter((option) => option.id === effortIds[provider]);
-  if (effortOptions.length !== 1 || !effortOptions[0].options?.some((value) => value.id === effort)
+  const effortOptions = (model.options ?? []).filter((option) => option.id === effortIds[provider]);
+  if (effortOptions.length !== 1 || !optionValues(effortOptions[0])?.includes(effort)
     || (provider === 'grok' && effort === 'max')) {
     throw new Error(`unsupported effort ${effort} for ${provider}/${model.id}`);
   }

package/skills/axstack-cleanup/SKILL.md

@@ -43,6 +43,27 @@ Preserve unknown files, unmerged author work, ambiguous publication, and evidenc
 Do not force removal, bulk-clean, edit a runtime database, or add a scheduler,
 daemon or state machine. Report other projects' resources; never touch them.
 
+## Wait registrations and owned wakes
+
+Follow [Bounded recovery boundary](../axstack/references/t3-runtime.md#bounded-recovery-boundary)
+and [Waiting-turn and closing records](../axstack/references/run-record.md#waiting-turn-and-closing-records)
+when ending an owner condition. On completion/cancellation/handoff, reconcile
+ownership and delete only run-owned schedule IDs with absence readback.
+Stop owned watches and clear only identified owned duplicate scheduled messages,
+recording exact IDs, scope, owner, lifetime and receipts. Preserve user messages
+and shared persistent schedules. Run completion unregisters only its own
+registration and preserves the shared service and other registrations.
+Without separately authorized shared-service lifetime, recovery ends at run
+close, empty scope or expiry, whichever comes first. Empty scope means no open
+wait registrations, rather than no eligible action in this pass. After expiry,
+perform cleanup-only with zero sends even if deletion failed.
+Unknown deletion or queue state is a scoped cleanup finding, never a reason to
+redo product work. Keep that resource ID and its cleanup owner until reconciled.
+Verify Stop/restart/provider-failure queue behavior before promising a timer
+wake; a timer cannot override a held queue. Use advertised interval/fixed-time/
+webhook operations, never an invented dedicated one-shot trigger. Recovery owns
+only its own resources; each Driver cleans its own watches, queues and schedules.
+
 ## Reconcile each candidate
 
 Take a fresh native inventory and bind every candidate to its exact projectId, attempt key, taskId/childThreadId/childRunId

package/skills/axstack-implement/SKILL.md

@@ -55,6 +55,8 @@ For substantive delegated or resumable work, use the shared
 [run record](../axstack/references/run-record.md). Reconcile it on restart with
 the approved scope, T3 threads/runs and forge state, exact revisions, tickets, and watches.
 Reuse valid owners and authors; ambiguity holds a replacement writer.
+When a logical Coordinator coordinates project drivers, follow
+[Coordinating multiple drivers](../axstack/references/t3-runtime.md#coordinating-multiple-drivers).
 
 At execution start, bind work to the T3 driver thread and one authoritative
 dispatch attempt. Preserve the actual thread/task/run IDs and process completion
@@ -281,8 +283,10 @@ For each PR:
    Load and follow [Round-3 step-back](references/step-back.md).
    Load and follow [Review-round budgets](../axstack/references/run-record.md#review-round-budgets) before dispatching any repair from the step-back.
 
-The T3 run watch reconciles every unsettled dispatch attempt; the bounded
-forge check wait is the only other implementation wait.
+The T3 run watch reconciles unsettled launched-fallback Writer runs; native
+completion delivers delegated receipts. Never status-check running delegate_task
+children on scheduled wakes. The bounded forge check wait is the only other
+implementation wait.
 After verified readback of every own PR publication, the driver arms or joins
 its maintain-mode chat-run watch under [Autopilot](../axstack/references/autopilot.md).
 That watch owns the bound T3 schedule wake; its runtime sets the cadence.
@@ -290,10 +294,13 @@ A turn with unsettled launched threads must end only under the bound-watch rule
 With settled threads, end a turn only when every required PR is `merge-ready` or `held`.
 Follow [Route each wake](../axstack-watch/SKILL.md#4-route-each-wake).
 Follow [Advised holds](../axstack/references/contracts.md#advised-holds) when raising eligible holds.
-Raise user-decision and serious-risk holds in the T3 driver thread and end the
-turn waiting on the decision. Serious risks are raised immediately.
+Raise user-decision and serious-risk holds in the owning T3 driver thread and
+end the turn waiting on the decision when all remaining authorized work is held.
+Continue independent authorized work under Autopilot's scoped-hold rules.
+Serious risks are raised immediately.
 After bounded safe recovery, raise a genuine blocked operation that still needs
-the user in the T3 driver thread, and the driver ends its turn waiting on it.
+the user in the owning T3 driver thread, and the driver ends its turn waiting on it
+when all remaining authorized work is held.
 
 Merge-ready opens the merge boundary. Own PRs default to automatic merge under
 [watch §5](../axstack-watch/SKILL.md#5-state-readiness-precisely).

package/skills/axstack-review/references/review-candidate.md

@@ -137,7 +137,7 @@ This section applies to peer and authored PR modes.
    For an `axstack-verify create` PR, the reviewer drives the candidate's recipe because the base has none.
    The author never performs this review drive.
    The reviewer drives each affected feature and records that drive as the `Final-head check`.
-   Delegate browser drives to `axstack-ui-verifier` with the feature file path.
+   Delegate browser drives to `axstack-ui-verifier` with the feature file path; device drives follow [UI verification](../../axstack/references/ui-verification.md#android-device-and-webpwa-dual-run)'s dual-run trigger.
    Running the applicable surface counts as spin-up; a CLI run qualifies.
    Use loopback and isolated instances under [axstack-verify](../../axstack-verify/SKILL.md#isolate-every-attempt).