axstack 0.54.0 → 0.56.0

package/skills/axstack/references/workspace-hygiene.md

@@ -1,5 +1,13 @@
 # Workspace hygiene for driver-owned T3 runs
 
+For remote nonwriters, apply [host-qualified retrieval and retirement](fleet-dispatch.md#retrieval-and-retirement).
+Resolve task status on origin and thread/run/settlement on the actual destination.
+Archive and read back exact evidence on origin before retiring only the owned
+T3-created reviewer checkout. Bind host/environment/path and candidate/base SHA;
+never use an origin filesystem path as a destination path. Unknown liveness,
+ownership or user takeover preserves that resource. Validation precedes deletion
+in separate sequential calls; preserve unknown ignored artifacts.
+
 This is a prompt contract, not a cleanup daemon. Follow [T3 runtime](t3-runtime.md)
 for native identities, terminal run evidence and schema. Dispatched workers never
 sweep or remove another session. A scheduled pass with recorded cleanup authority

package/skills/axstack/scripts/dispatch-plan.js

@@ -1,6 +1,9 @@
 import { readFileSync, writeFileSync } from 'node:fs';
+import { inspectFleetReceipt } from './fleet-receipt.js';
+import { bindFleet } from './fleet-dispatch.js';
 
-const flags = ['--role', '--roles', '--capabilities', '--kind', '--verify', '--out'];
+const fleetFlags = ['--recommendation', '--fleet-input', '--now', '--config-digest'];
+const flags = ['--role', '--roles', '--capabilities', '--kind', '--verify', '--out', ...fleetFlags];
 const nonempty = (value) => typeof value === 'string' && value.trim().length > 0;
 const help = `Usage: bun dispatch-plan.js --role <id> --roles <roles.json>
   --capabilities <saved.json> --kind task|launch
@@ -13,6 +16,10 @@ Example: bun dispatch-plan.js --role axstack-author --roles roles.json --capabil
 --kind          task emits target and, for axstack-author, isolation:"worktree"; launch emits modelSelection
 --verify        Compare t3_thread_configuration JSON; print evidence then MATCH or each mismatch
 --out           Save the payload as full JSON here; stdout is an input/path/omitted-count summary
+--recommendation Saved fleet-route recommendation; requires all following fleet flags
+--fleet-input   Saved complete selector input, including exact reviewed config bytes
+--now           Injected nonnegative epoch-ms evaluation time matching the recommendation
+--config-digest Run-pinned config SHA-256; must match facts and recommendation
 --help          Show all flags and exit codes
 
 Read-only inputs: reads supplied JSON, spawns adjacent resolve-models.js, writes stdout/stderr.
@@ -22,6 +29,14 @@ Large verification retains its exit code, prints mismatches and advises --out on
 An unwritable --out still prints verification mismatches and retains exit 2.
 An omitted provider label is unknown; exact instance/model/options/mode checks still apply.
 Never dispatches or changes snapshots. Reuse recorded exact model pins as given.
+Fleet --capabilities is the selected destination's raw saved catalog, digest-bound
+by its destination facts. It is never the origin catalog by default.
+Fleet verification requires environmentId/projectId and fleetBinding alongside
+the effective T3 configuration. C3 collects that host-qualified evidence envelope.
+Optional input.nativeDestination validates saved native forwarded reads.
+Optional --verify fleetAttempt/fleetReceipt validates host-qualified terminal facts;
+--out retains per-term receipt evidence. Synthetic bindings cannot authenticate reads.
+Coordinator routes remain unsupported here. A plan grants no launch authority.
 Exit codes: 0 ok, 1 error, 2 hold (including incomplete read-back).
 `;
 
@@ -39,9 +54,12 @@ function argumentsFrom(args) {
     if (flag in options) throw new Error(`duplicate argument ${flag}; pass it once`);
     options[flag] = value;
   }
-  for (const flag of flags.filter((flag) => !['--verify', '--out'].includes(flag))) {
+  for (const flag of ['--role', '--roles', '--capabilities', '--kind']) {
     if (!options[flag]) throw new Error(`expected ${flag}; pass ${flag} <value>`);
   }
+  if (fleetFlags.some((flag) => options[flag])) {
+    for (const flag of fleetFlags) if (!options[flag]) throw new Error(`expected ${flag} for fleet binding`);
+  }
   if (!['task', 'launch'].includes(options['--kind'])) throw new Error('expected --kind task|launch; pass --kind task or --kind launch');
   return options;
 }
@@ -60,7 +78,7 @@ function normalizedOptions(options) {
   return JSON.stringify(entries.sort(([left], [right]) => left.localeCompare(right)));
 }
 
-function verify(configuration, provider, model, options) {
+function verify(configuration, provider, model, options, fleet) {
   const mismatches = [];
   const selection = configuration?.modelSelection;
   const compare = (field, expected, observed, equal = expected === observed) => {
@@ -77,7 +95,19 @@ function verify(configuration, provider, model, options) {
   compare('options', options, selection?.options,
     normalizedOptions(options) === normalizedOptions(selection?.options));
   compare('runtimeMode', 'full-access', configuration?.runtimeMode);
-  return { mismatches, ...(selection?.provider == null ? {
+  if (fleet) {
+    for (const [field, expected] of Object.entries(fleet.destination)) compare(field, expected, configuration?.[field]);
+    for (const [field, expected] of Object.entries(fleet.fleetBinding)) compare(field, expected, configuration?.fleetBinding?.[field]);
+  }
+  let receiptTerms;
+  if (fleet && configuration?.fleetReceipt !== undefined) {
+    receiptTerms = inspectFleetReceipt(configuration.fleetReceipt, {
+      attempt: configuration.fleetAttempt, recommendation: fleet.recommendation,
+      recommendationJSON: fleet.recommendationJSON, now: fleet.now,
+    });
+    for (const term of receiptTerms) if (term.state !== 'pass') mismatches.push(`${term.code}: ${term.state}; evidence ${JSON.stringify(term.evidence)}`);
+  }
+  return { mismatches, ...(receiptTerms ? { receiptTerms } : {}), ...(selection?.provider == null ? {
     providerEvidence: `provider: unknown; expected ${JSON.stringify(provider)}; observed missing; `
       + 'provider binding checked via instanceId and saved capabilities',
   } : {}) };
@@ -136,16 +166,30 @@ function plan(argv, io) {
     '--effort', role.thinkingOptionId, ...modelArgs], { stdout: 'pipe', stderr: 'pipe' });
   if (resolved.stderr.length) io.stderr(resolved.stderr.toString());
   if (resolved.exitCode !== 0) return resolved.exitCode === 1 ? 2 : 1;
-  const { model, effortOption, providerInstanceId } = JSON.parse(resolved.stdout.toString());
-  const options = effortOption ? [effortOption] : [];
+  const resolution = JSON.parse(resolved.stdout.toString());
+  const { model, effortOption, providerInstanceId } = resolution;
+  let fleet;
+  if (args['--recommendation']) {
+    if (!/^\d+$/.test(args['--now'])) throw new Error('evaluation-time');
+    const recommendationJSON = readFileSync(args['--recommendation'], 'utf8');
+    const recommendation = JSON.parse(recommendationJSON);
+    fleet = bindFleet(readJSON(args['--fleet-input']), recommendation,
+      args['--config-digest'], Number(args['--now']), readFileSync(args['--capabilities'], 'utf8'),
+      resolution, role.id === 'axstack-author');
+    fleet.recommendation = recommendation;
+    fleet.recommendationJSON = recommendationJSON;
+    fleet.now = Number(args['--now']);
+  }
+  const options = fleet?.options ?? (effortOption ? [effortOption] : []);
   if (args['--verify']) {
-    const verification = verify(readJSON(args['--verify']), providerInstanceId, model, options);
+    const verification = verify(readJSON(args['--verify']), providerInstanceId, model, options, fleet);
     emit(verification);
     return verification.mismatches.length ? 2 : 0;
   }
   const selection = { [args['--kind'] === 'launch' ? 'instanceId' : 'providerInstanceId']: providerInstanceId,
-    model, options };
+    model, options, ...(args['--kind'] === 'task' ? fleet?.destination : {}) };
   emit({ [args['--kind'] === 'launch' ? 'modelSelection' : 'target']: selection, runtimeMode: 'full-access',
+    ...(fleet ? { fleetBinding: fleet.fleetBinding, ...(args['--kind'] === 'launch' ? fleet.destination : {}) } : {}),
     ...(args['--kind'] === 'task' && role.id === 'axstack-author' ? { isolation: 'worktree' } : {}) });
   return 0;
 }

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

@@ -0,0 +1,78 @@
+// Configuration is reviewed data. This module does not read account-local files.
+export function fail(code) { throw new Error(code); }
+export const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+export const text = (value) => typeof value === 'string' && value.trim().length > 0;
+export const time = (value) => Number.isSafeInteger(value) && value >= 0;
+const bp = (value) => Number.isInteger(value) && value >= 0 && value <= 10000;
+
+// Canonical comparison for JSON settings, independent of property insertion order.
+export function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (record(value)) return `{${Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(',')}}`;
+  return JSON.stringify(value);
+}
+
+export function evidence(value, environmentId, now) {
+  return record(value) && value.environmentId === environmentId && text(value.pointer)
+    && time(value.observedAt) && value.observedAt <= now;
+}
+
+export function parseFleetConfig(configText, expectedDigest) {
+  if (!text(configText)) fail('missing-config');
+  if (typeof expectedDigest !== 'string' || !/^[a-f0-9]{64}$/.test(expectedDigest)) fail('config-digest');
+  const digest = new Bun.CryptoHasher('sha256').update(configText).digest('hex');
+  if (digest !== expectedDigest) fail('config-digest-mismatch');
+  let config;
+  try { config = JSON.parse(configText); } catch { fail('config-json'); }
+  if (!record(config) || config.schemaVersion !== 1) fail('schema-version: config');
+  if (!Array.isArray(config.hosts) || config.hosts.length === 0) fail('config-host');
+  const ids = new Set();
+  const environments = new Set();
+  for (const host of config.hosts) {
+    if (!record(host) || !text(host.id) || !text(host.environmentId) || ids.has(host.id)
+      || environments.has(host.environmentId) || !record(host.capabilities)) fail('config-host');
+    ids.add(host.id); environments.add(host.environmentId);
+    if (!bp(host.fallbackLimitBp)) fail('config-threshold');
+  }
+  if (!bp(config.balanceLimitBp)) fail('config-threshold');
+  const order = (value, complete) => Array.isArray(value) && value.every((id) => ids.has(id))
+    && new Set(value).size === value.length && (!complete || value.length === ids.size);
+  if (!order(config.defaultOrder, true) || !order(config.pool, false) || !record(config.taskOrders)
+    || Object.values(config.taskOrders).some((o) => !order(o, true))) fail('config-order');
+  if (!Array.isArray(config.routes)) fail('config-route');
+  const routeIds = new Set();
+  for (const route of config.routes) {
+    if (!record(route) || !text(route.id) || routeIds.has(route.id) || !text(route.originEnvironmentId)
+      || !environments.has(route.environmentId) || typeof route.enabled !== 'boolean'
+      || !['local', 'remote', 'remote-author-coordinator'].includes(route.kind)
+      || (route.kind === 'local') !== (route.originEnvironmentId === route.environmentId)) fail('config-route');
+    routeIds.add(route.id);
+  }
+  return config;
+}
+
+export function validateInput(input, now) {
+  if (!time(now)) fail('evaluation-time');
+  if (!record(input) || input.schemaVersion !== 1) fail('schema-version: input');
+  if (!record(input.origin) || !text(input.origin.environmentId) || !record(input.origin.versions)) fail('origin-schema');
+  const r = input.request;
+  if (!record(r) || !text(r.task) || !['reader', 'author'].includes(r.role)
+    || !Array.isArray(r.requiredCapabilities) || !r.requiredCapabilities.every(text)
+    || !text(r.repositoryId) || !text(r.providerInstanceId) || !text(r.model)
+    || !record(r.options) || !text(r.runtimeMode)) fail('request-schema');
+  for (const key of ['destinations', 'routeFacts', 'telemetry', 'assignments', 'pendingAssignments']) {
+    if (!Array.isArray(input[key])) fail(`${key}-schema`);
+  }
+  if (!['known', 'unknown'].includes(input.inventoryStatus)
+    || (input.inventoryStatus === 'known' && (!time(input.inventoryObservedAt) || input.inventoryObservedAt > now))) fail('inventory-schema');
+  if (!record(input.exclusions) || !record(input.exclusions.hosts) || !record(input.exclusions.routes)
+    || !Object.values(input.exclusions.hosts).every(text) || !Object.values(input.exclusions.routes).every(text)) fail('exclusions-schema');
+  // Reject ambiguous joins, rather than choosing whichever duplicate arrived first.
+  for (const [key, id] of [['destinations', 'environmentId'], ['routeFacts', 'routeId'], ['telemetry', 'environmentId']]) {
+    const seen = new Set();
+    for (const value of input[key]) {
+      if (!record(value) || !text(value[id]) || seen.has(value[id])) fail(`${key}-schema`);
+      seen.add(value[id]);
+    }
+  }
+}

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

@@ -0,0 +1,39 @@
+// Validate explicit saved native reads. These bindings do not authenticate input.
+import { canonical, text, time } from './fleet-config.js';
+
+export function inspectDestination(observation, recommendation, capabilitiesText, now) {
+  const terms = [];
+  const term = (code, pass, evidence, missing = evidence == null) => terms.push({ code,
+    state: pass ? 'pass' : missing ? 'unknown' : 'fail', evidence: evidence ?? null });
+  const s = recommendation.selected;
+  const o = observation ?? {};
+  for (const [name, tool, environmentId, args] of [
+    ['environment', 't3_environment_read', s.environmentId, {}],
+    ['project', 't3_project_read', s.environmentId, { projectId: s.projectId }],
+    ['capabilities', 'orchestrator_capabilities', s.environmentId, {}],
+    ['links', 't3_environment_links', recommendation.originEnvironmentId, {}],
+  ]) {
+    const read = o[name];
+    term('destination-observation', read?.tool === tool && read?.environmentId === environmentId
+      && canonical(read?.args) === canonical(args) && time(read?.observedAt)
+      && read.observedAt <= now && text(read?.evidence), read);
+  }
+  term('destination-identity', o.environment?.value?.environmentId === s.environmentId,
+    o.environment?.value?.environmentId);
+  term('destination-project', o.project?.value?.id === s.projectId && text(o.project?.value?.workspaceRoot),
+    o.project?.value);
+  term('destination-repository', o.project?.value?.repositoryIdentity?.canonicalKey === s.repositoryId,
+    o.project?.value?.repositoryIdentity);
+  term('destination-catalog', o.capabilities?.valueText === capabilitiesText, o.capabilities?.valueText);
+  const catalog = JSON.parse(capabilitiesText);
+  const provider = catalog.providers?.find((v) => v.providerInstanceId === recommendation.request.providerInstanceId);
+  term('destination-execution', provider?.canRunChildTask === true
+    && provider?.runtimeModes?.includes(recommendation.request.runtimeMode), provider,
+  provider?.canRunChildTask == null || !Array.isArray(provider?.runtimeModes));
+  const local = s.environmentId === recommendation.originEnvironmentId;
+  const link = o.links?.value?.links?.find((v) => v.environmentId === s.environmentId);
+  term('destination-access', o.links?.value?.environmentId === recommendation.originEnvironmentId
+    && (local || (link?.status === 'reachable' && link?.access === recommendation.request.runtimeMode
+      && Date.parse(link?.expiresAt) > now)), local ? o.links?.value : link);
+  return terms;
+}

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

@@ -0,0 +1,47 @@
+// Bind supplied placement facts to a plan. No reads, dispatch or authority grant.
+import { inspectDestination } from './fleet-destination.js';
+import { canonical, record, text } from './fleet-config.js';
+import { recommend } from './fleet-route.js';
+
+export function bindFleet(input, saved, configDigest, now, capabilitiesText, resolved, author) {
+  const hold = (code) => { throw Object.assign(new Error(code), { exitCode: 2 }); };
+  if (saved?.schemaVersion !== 1) hold('schema-version: recommendation');
+  if (configDigest !== input?.configDigest) hold('config-digest-mismatch');
+  let current;
+  try { current = recommend(input, now); } catch (error) { hold(error.message); }
+  if (canonical(saved) !== canonical(current)) hold('recommendation-mismatch');
+  const selected = current.selected;
+  if (!selected) hold('no-executable-route');
+  // Coordinator enablement/lifecycle is a later capability, never inferred here.
+  if (selected.routeKind === 'remote-author-coordinator') hold('remote-author-not-enabled');
+  const digest = selected.destinationCapabilitiesDigest;
+  if (typeof digest !== 'string' || !/^[a-f0-9]{64}$/.test(digest)) hold('capabilities-digest-missing');
+  if (new Bun.CryptoHasher('sha256').update(capabilitiesText).digest('hex') !== digest) hold('capabilities-digest-mismatch');
+  if (input.nativeDestination !== undefined) {
+    const mismatch = inspectDestination(input.nativeDestination, current, capabilitiesText, now)
+      .find((term) => term.state !== 'pass');
+    if (mismatch) hold(mismatch.code);
+  }
+  const request = current.request;
+  const { model, providerInstanceId, effortOption } = resolved;
+  if (request.providerInstanceId !== providerInstanceId || request.model !== model
+    || request.runtimeMode !== 'full-access' || (request.role === 'author') !== author
+    || !record(request.options) || request.options[effortOption.id] !== effortOption.value) hold('settings-mismatch');
+  const catalog = JSON.parse(capabilitiesText);
+  const instance = catalog.providers.find((p) => p.providerInstanceId === providerInstanceId);
+  const models = instance.models.filter((m) => m.id === model);
+  if (models.length !== 1) hold('capabilities-model-ambiguous');
+  const options = Object.entries(request.options).sort(([a], [b]) => a.localeCompare(b)).map(([id, value]) => {
+    const definitions = models[0].options.filter((o) => o.id === id);
+    if (!text(id) || !['string', 'boolean'].includes(typeof value) || definitions.length !== 1) hold('unsupported-option');
+    const definition = definitions[0];
+    const values = definition.values ?? definition.options?.map((v) => v.id);
+    if (!values?.includes(value)) hold(`unsupported-option: ${id}`);
+    return { id, value };
+  });
+  return {
+    options, destination: { environmentId: selected.environmentId, projectId: selected.projectId },
+    fleetBinding: { configDigest, destinationSnapshotId: selected.destinationSnapshotId,
+      destinationCapabilitiesDigest: digest },
+  };
+}

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

@@ -0,0 +1,161 @@
+import { nativeAssignments } from './fleet-inventory.js';
+import { canonical, evidence, fail, record, text, time } from './fleet-config.js';
+
+const terminal = new Set(['completed', 'failed', 'cancelled', 'canceled', 'rejected']);
+const states = new Set([...terminal, 'pending', 'queued', 'running', 'waiting', 'blocked']);
+const qualified = (value) => text(value) && /^.+:.+$/.test(value);
+
+export function assignmentCounts(input, hosts, now) {
+  if (input.nativeInventory !== undefined) {
+    const normalized = nativeAssignments(input.nativeInventory, hosts, now);
+    const counts = assignmentCounts(normalized, hosts);
+    return { ...counts, inventoryReasons: normalized.inventoryReasons,
+      inventoryEvidence: normalized.inventoryEvidence,
+      ...(normalized.inventoryStatus === 'unknown' ? {
+        pendingLowerBound: counts.byEnvironment,
+        byEnvironment: Object.fromEntries(hosts.map((h) => [h.environmentId, null])),
+      } : {}) };
+  }
+  const byEnvironment = Object.fromEntries(hosts.map((h) => [h.environmentId, 0]));
+  const inventory = new Map();
+  const clients = new Map();
+  const pendingTasks = new Map();
+  for (const a of input.assignments) {
+    if (!record(a) || !qualified(a.assignmentId) || !text(a.environmentId) || !states.has(a.state)) fail('assignment-schema');
+    const previous = inventory.get(a.assignmentId);
+    if (previous && (previous.environmentId !== a.environmentId || previous.state !== a.state)) fail('assignment-conflict');
+    inventory.set(a.assignmentId, a);
+  }
+  const count = (environmentId) => {
+    if (Object.hasOwn(byEnvironment, environmentId)) byEnvironment[environmentId]++;
+  };
+  if (input.inventoryStatus === 'known') {
+    for (const a of inventory.values()) if (!terminal.has(a.state)) count(a.environmentId);
+  }
+  for (const p of input.pendingAssignments) {
+    if (!record(p) || !text(p.clientRequestId) || !text(p.environmentId)
+      || (p.taskId !== undefined && !qualified(p.taskId))) fail('pending-assignment-schema');
+    const previous = clients.get(p.clientRequestId);
+    if (previous && (previous.environmentId !== p.environmentId || previous.taskId !== p.taskId)) fail('assignment-conflict');
+    if (previous) continue;
+    clients.set(p.clientRequestId, p);
+    if (p.taskId !== undefined) {
+      const known = input.inventoryStatus === 'known' ? inventory.get(p.taskId) : null;
+      const pendingEnvironment = pendingTasks.get(p.taskId);
+      if ((known && known.environmentId !== p.environmentId)
+        || (pendingEnvironment && pendingEnvironment !== p.environmentId)) fail('assignment-conflict');
+      if (known || pendingEnvironment) continue;
+      pendingTasks.set(p.taskId, p.environmentId);
+    }
+    count(p.environmentId);
+  }
+  return { byEnvironment, inventoryStatus: input.inventoryStatus,
+    inventoryObservedAt: input.inventoryObservedAt ?? null, pendingRecords: clients.size,
+    provenance: input.inventoryStatus === 'known' ? 'inventory-plus-pending' : 'pending-only' };
+}
+
+// Scale the shortest decimal representation, avoiding binary multiplication overshoot.
+function fractionBp(fraction) {
+  const [mantissa, exponent = '0'] = String(fraction).split('e');
+  const [whole, decimals = ''] = mantissa.split('.');
+  const numerator = BigInt(whole + decimals);
+  const scale = decimals.length - Number(exponent) - 4;
+  if (scale <= 0) return Number(numerator * (10n ** BigInt(-scale)));
+  const denominator = 10n ** BigInt(scale);
+  return Number((numerator + denominator - 1n) / denominator);
+}
+
+export function telemetry(sample, now) {
+  const provenance = Object.fromEntries(['source', 'scope', 'durationMs', 'intervalMs', 'windowStartedAt',
+    'windowEndedAt', 'windowKind', 'receivedAt', 'timeoutMs'].filter((key) => sample?.[key] !== undefined)
+    .map((key) => [key, sample[key]]));
+  const ageMs = time(sample?.receivedAt) ? now - sample.receivedAt : null;
+  const unknown = (reason) => ({ ...provenance, status: 'unknown', reason, ageMs });
+  if (!sample) return unknown('missing');
+  if (sample.timedOut === true) return unknown('timeout');
+  if (sample.status !== 'ok') return unknown(text(sample.status) ? sample.status : 'failed');
+  if (!time(sample.receivedAt)) return unknown('invalid-received-time');
+  if (ageMs < 0) return unknown('future');
+  if (ageMs > 15000) return unknown('stale');
+  if (!Number.isSafeInteger(sample.durationMs) || sample.durationMs < 5000
+    || sample.scope !== 'whole-host' || !text(sample.source)) return unknown('unusable-provenance');
+  if (sample.windowStartedAt !== undefined && (!time(sample.windowStartedAt)
+    || sample.receivedAt - sample.windowStartedAt < sample.durationMs)) return unknown('inconsistent-window');
+  if ((sample.intervalMs !== undefined && (!Number.isSafeInteger(sample.intervalMs)
+    || sample.intervalMs < 5000 || sample.intervalMs > 60000 || sample.intervalMs > sample.durationMs))
+    || (sample.windowEndedAt !== undefined && (!time(sample.windowEndedAt)
+      || !time(sample.windowStartedAt) || sample.windowEndedAt > sample.receivedAt
+      || sample.windowEndedAt - sample.windowStartedAt < sample.durationMs))) return unknown('inconsistent-window');
+  const toBp = (name) => {
+    const points = sample[`${name}Bp`];
+    const fraction = sample[`${name}Fraction`];
+    // Exactly one representation: conflicting fields must not silently win.
+    if (points !== undefined && fraction !== undefined) return null;
+    if (fraction !== undefined) return typeof fraction === 'number' && Number.isFinite(fraction)
+      && fraction >= 0 && fraction <= 1 ? fractionBp(fraction) : null;
+    return Number.isInteger(points) && points >= 0 && points <= 10000 ? points : null;
+  };
+  const cpuBp = toBp('cpu'); const ramBp = toBp('ram');
+  if (cpuBp === null || ramBp === null) return unknown('malformed');
+  // If the collector supplies latest RAM as well as an average, retain spikes.
+  const latest = sample.ramLatestBp;
+  if (latest !== undefined && (!Number.isInteger(latest) || latest < 0 || latest > 10000)) return unknown('malformed');
+  return { status: 'measured', ageMs, cpuBp, ramBp, ramLatestBp: latest ?? null,
+    loadBp: Math.max(cpuBp, ramBp, latest ?? 0), receivedAt: sample.receivedAt,
+    source: sample.source, scope: sample.scope, durationMs: sample.durationMs,
+    windowStartedAt: sample.windowStartedAt ?? null, windowEndedAt: sample.windowEndedAt ?? null,
+    intervalMs: sample.intervalMs ?? null, windowKind: sample.windowKind ?? null,
+    timeoutMs: sample.timeoutMs ?? null };
+}
+
+const versionsMatch = (a, b) => record(a) && record(b) && text(a.t3) && text(a.axstack)
+  && a.t3 === b.t3 && a.axstack === b.axstack;
+
+export function routeReasons(route, host, destination, facts, input, now) {
+  const reasons = [];
+  const add = (code) => { if (!reasons.includes(code)) reasons.push(code); };
+  const remote = route.environmentId !== input.origin.environmentId;
+  const r = input.request;
+  if (Object.hasOwn(input.exclusions.hosts, host.id)) add('excluded-host');
+  if (Object.hasOwn(input.exclusions.routes, route.id)) add('excluded-route');
+  if (!route.enabled) add('route-disabled');
+  if (route.kind === 'remote-author-coordinator' && r.role !== 'author') add('route-role-mismatch');
+  if (!evidence(route.evidence, host.environmentId, now)) add('evidence-unproven');
+  if (!facts) add('route-unproven');
+  else {
+    if (facts.reachable !== true) add(facts.reachable === false ? 'offline' : 'route-unproven');
+    if (facts.authorized !== true) add(facts.authorized === false ? 'unauthorized' : 'route-unproven');
+    if (remote && (!time(facts.expiresAt) || facts.expiresAt <= now)) add('link-expired');
+    if (!evidence(facts.evidence, host.environmentId, now)) add('evidence-unproven');
+  }
+  if (destination?.status !== 'known') add('destination-unproven');
+  else {
+    if (!time(destination.observedAt) || destination.observedAt > now
+      || !evidence(destination.evidence, host.environmentId, now)) add('evidence-unproven');
+    if (!text(destination.snapshotId) || facts?.destinationSnapshotId !== destination.snapshotId) add('target-snapshot-mismatch');
+    if (!record(destination.project) || !text(destination.project.id)) add('project-missing');
+    else if (destination.project.repositoryId !== r.repositoryId) add('project-mismatch');
+    const e = destination.execution;
+    if (!record(e) || e.available !== true) add('execution-unproven');
+    else if (e.providerInstanceId !== r.providerInstanceId || e.model !== r.model
+      || e.runtimeMode !== r.runtimeMode || canonical(e.options) !== canonical(r.options)) add('execution-mismatch');
+  }
+  const required = [...r.requiredCapabilities, ...(r.role === 'author' ? ['worktree-isolation'] : [])];
+  for (const name of required) {
+    for (const capabilities of [host.capabilities, destination?.capabilities]) {
+      const fact = capabilities?.[name];
+      if (fact?.value !== true || !evidence(fact.evidence, host.environmentId, now)) add('capability-unproven');
+    }
+  }
+  if (r.role === 'author' && remote) {
+    if (route.kind !== 'remote-author-coordinator') add('remote-author-unsupported');
+    else {
+      const proof = route.authorProof;
+      if (proof?.gatesPassed !== true || proof.originEnvironmentId !== input.origin.environmentId
+        || proof.environmentId !== host.environmentId || !evidence(proof.evidence, host.environmentId, now)
+        || !versionsMatch(proof.originVersions, input.origin.versions)
+        || !versionsMatch(proof.destinationVersions, destination?.versions)) add('remote-author-unproven');
+    }
+  }
+  return reasons;
+}

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

@@ -0,0 +1,76 @@
+// Normalize saved native observations only. No discovery, reservations or dispatch.
+import { canonical, text, time } from './fleet-config.js';
+
+const active = new Set(['queued', 'running', 'waiting']);
+const terminal = new Set(['completed', 'failed', 'cancelled', 'interrupted']);
+// JSON tuple encoding avoids collisions between IDs containing punctuation.
+const identity = (environmentId, taskId) => JSON.stringify([environmentId, taskId]);
+
+export function nativeAssignments(snapshot, hosts, now) {
+  const reasons = new Set();
+  const unknown = (code) => reasons.add(code);
+  const environments = new Set(hosts.map((h) => h.environmentId));
+  const tasks = new Map();
+  const assignments = new Map();
+  const pending = new Map();
+  if (snapshot?.complete !== true || !time(snapshot?.observedAt) || !time(now) || snapshot.observedAt > now || !text(snapshot?.evidence)
+    || !Array.isArray(snapshot?.tasks) || !Array.isArray(snapshot?.pending)) unknown('inventory-incomplete');
+  for (const item of Array.isArray(snapshot?.tasks) ? snapshot.tasks : []) {
+    if (!text(item?.origin?.environmentId) || !text(item?.origin?.threadId) || !text(item?.task?.taskId)) {
+      unknown('origin-unknown'); continue;
+    }
+    const key = identity(item.origin.environmentId, item.task.taskId);
+    const previous = tasks.get(key);
+    if (previous && canonical(previous) !== canonical(item)) unknown('assignment-conflict');
+    tasks.set(key, item);
+  }
+  for (const [key, item] of tasks) {
+    const task = item.task;
+    const environmentId = task.remoteChild?.environmentId
+      ?? (text(task.childThreadId) ? item.origin.environmentId : null);
+    if (!text(environmentId)) { unknown('destination-unknown'); continue; }
+    if (!environments.has(environmentId)) { unknown('host-unmapped'); continue; }
+    if (task.remoteChild && !text(task.remoteChild.threadId)) { unknown('destination-unknown'); continue; }
+    if (!active.has(task.status) && !terminal.has(task.status)) { unknown('task-state-unknown'); continue; }
+    let rootKey = key;
+    if (item.assignmentRoot) {
+      rootKey = identity(item.assignmentRoot.environmentId, item.assignmentRoot.taskId);
+      const root = tasks.get(rootKey);
+      if (!root || root.assignmentRoot) { unknown('assignment-root-unknown'); continue; }
+      const rootEnvironment = root.task.remoteChild?.environmentId
+        ?? (text(root.task.childThreadId) ? root.origin.environmentId : null);
+      if (rootEnvironment !== environmentId) { unknown('assignment-conflict'); continue; }
+    }
+    const previous = assignments.get(rootKey);
+    const state = active.has(task.status) || task.hasPendingChildRuns === true
+      || task.workState === 'waiting_for_children' ? 'running' : 'completed';
+    // A terminal coordinator with live descendants remains active.
+    assignments.set(rootKey, { assignmentId: `task:${rootKey}`, environmentId,
+      state: previous?.state === 'running' ? 'running' : state });
+  }
+  for (const item of Array.isArray(snapshot?.pending) ? snapshot.pending : []) {
+    if (!text(item?.origin?.environmentId) || !text(item?.origin?.threadId) || !text(item?.clientRequestId)) {
+      unknown('origin-unknown'); continue;
+    }
+    if (!environments.has(item.environmentId)) { unknown('host-unmapped'); continue; }
+    const key = JSON.stringify([item.origin.environmentId, item.origin.threadId, item.clientRequestId]);
+    const value = { clientRequestId: key, environmentId: item.environmentId };
+    if (item.taskId !== undefined) {
+      if (!text(item.taskId)) { unknown('origin-unknown'); continue; }
+      const taskKey = identity(item.origin.environmentId, item.taskId);
+      const known = tasks.get(taskKey);
+      const rootKey = known?.assignmentRoot
+        ? identity(known.assignmentRoot.environmentId, known.assignmentRoot.taskId) : taskKey;
+      value.taskId = `task:${rootKey}`;
+      const reflected = assignments.get(rootKey);
+      if (reflected && reflected.environmentId !== item.environmentId) unknown('assignment-conflict');
+    }
+    const previous = pending.get(key);
+    if (previous && canonical(previous) !== canonical(value)) unknown('assignment-conflict');
+    pending.set(key, value);
+  }
+  return { inventoryStatus: reasons.size ? 'unknown' : 'known',
+    inventoryObservedAt: snapshot?.observedAt ?? null, inventoryReasons: [...reasons],
+    inventoryEvidence: snapshot?.evidence ?? null,
+    assignments: [...assignments.values()], pendingAssignments: [...pending.values()] };
+}

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

@@ -0,0 +1,31 @@
+// Linux aggregate CPU counters; guest/guest_nice are already in user/nice.
+const malformed = () => { throw Error('malformed'); };
+const bp = (n, d) => Number((n * 10000n + d - 1n) / d);
+export function parseProc(value) {
+  if (typeof value !== 'string' || value.length > 65536) malformed();
+  const parts = value.split('\n---AXSTACK-MEM---\n');
+  if (parts.length !== 2) malformed();
+  const lines = parts[0].split('\n').filter((s) => /^cpu\s/.test(s));
+  if (lines.length !== 1) malformed();
+  const counters = lines[0].trim().split(/\s+/).slice(1);
+  if (counters.length < 8 || counters.length > 10
+    || counters.some((v) => !/^\d+$/.test(v) || !Number.isSafeInteger(Number(v)))) malformed();
+  const memory = (key) => {
+    const rows = parts[1].split('\n').filter((s) => s.startsWith(`${key}:`));
+    const match = rows.length === 1 && rows[0].match(new RegExp(`^${key}:\\s+(\\d+) kB\\s*$`));
+    if (!match || !Number.isSafeInteger(Number(match[1]))) malformed();
+    return BigInt(match[1]);
+  };
+  const total = memory('MemTotal'); const available = memory('MemAvailable');
+  if (total <= 0n || available > total) malformed();
+  return { counters: counters.slice(0, 8).map(BigInt), total, used: total - available };
+}
+
+export function pressure(first, last) {
+  const deltas = last.counters.map((v, i) => v - first.counters[i]);
+  const total = deltas.reduce((a, b) => a + b, 0n);
+  if (deltas.some((v) => v < 0n) || total <= 0n || first.total !== last.total) throw Error('inconsistent-counters');
+  const busy = total - deltas[3] - deltas[4]; // idle and iowait only; steal is busy.
+  return { cpuBp: bp(busy, total), ramBp: bp(first.used + last.used, 2n * last.total),
+    ramLatestBp: bp(last.used, last.total) };
+}