@awebai/oats 0.25.8 → 0.26.0

package/bin/oats.mjs

@@ -2,13 +2,13 @@
 /**
  * oats — the OATS command line.
  *
- *   oats doctor [dir] [--json]              show the resolved config with origins
+ *   oats doctor [dir] [--soul <s>] [--json] show the deployment; --soul: the instructions an instance of <s> would carry
  *   oats onboard [<dir>] --workspace <ref>  realize a workspace here (oats-local.yaml +
  *                                          agents/), then sync
  *   oats sync [--dir <d>] [--json]          discover the workspace, confirm membership,
- *                                          resolve packages, approve, write the lock
+ *                                          resolve packages, write the lock
  *   oats package add|remove ...            edit `packages:` in the workspace file
- *   oats workspace status                  membership table, packages, approval
+ *   oats workspace status                  membership table, packages
  *   oats capabilities | oats souls         every visible item of the workspace
  *
  * Workspace model v2 (docs/design/2026-09-23-workspace-module-contracts.md §6):
@@ -17,30 +17,23 @@
  * `init` / `use` / `install` / `restore` / `list` / `catalog` / `remove` /
  * `migrate` / `trust` / `inject` are gone with the installed-capability tier.
  */
-import { existsSync, lstatSync, mkdirSync, readFileSync, readSync, realpathSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readSync, realpathSync, rmdirSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync, spawnSync } from "node:child_process";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { createHash } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import {
-  LAYERS, WORK_MODES, LEGACY_HOME_CAPABILITIES_DIR, OATS_VERSION, OAS_SCOPE_REMEDY, RETIRED_CAPABILITIES, detectOasScopes, retiredCapabilityReason, configChain, configCapabilityEntries, manifestOperations,
-  capabilityManifests, capabilityManifest, capabilityMissingRequires, capabilityTrust, capabilityExecutablePath, activateCapturedScaffold, loadCapturedDispatch, inspectPortableOnboarding, prepareCapturedComposition, resolveCapturedHelper, capturedNativeSessionAvailability, scaffoldCapturedInstance, startCapturedInstanceSession, withCapturedBindingFile, withCapturedInvocationContextFile,
-  readCapabilityLocks, admitCapturedAction, beginCapturedIntent, settleCapturedIntent, listInstalledPackages, readPackageLocks,
-  officialPackageCatalog, describeOfficialCatalog, approveAvailableCapability,
-  packageIntegrity, capabilityArtifactIntegrity, verifyCapabilityInstallation, installedCapabilityDir,
-  resolveOatsConfig, resolveWorkMode, composeInstanceAgentsMd, parseYamlNested, assertSafeConfigValue, stripInternalAnnotations, withConfigFile, teamAgentRoots,
-  findTeamAgent, findTeamInstance, findCapabilityAgent, findInstanceHome, findInstanceHomes, listCapabilityAgents, workspaceOf, stopInstanceSession, recomposeInstanceInstructions,
-  ensureRoot, findRoot, findAgent, listAgents, listInstances, servedIdentityLine, servedIdentityOf, listAgentDefs, createAgent as coreCreateAgent,
-  spawnInstance, spawnInstanceAsync, findModuleCapabilityAgent, capabilityAgentFromDir, retireInstance, inspectInstanceSession, inputInstanceSession, attachInstanceSession, startInstanceSession, upsertLocalAgent, defaultRepo, RELATIONS, validateLaunchConfig, resolveLaunchSelection, resolveLaunchExecutable, checkLaunchExecutable, missingLaunchEnvRefs, renderLaunchRecipe, describeLaunchCommand, redactLaunchRecipe, LAUNCH_RUNTIMES, LAUNCH_RECIPE_VERSION, parseLaunchCommand, resolveYolo, planLaunch, redactLaunchCommand, restartInstanceSession,
+  LAYERS, OATS_VERSION, manifestOperations,
+  capabilityManifests, capabilityTrust, capabilityExecutablePath,
+  officialPackageCatalog, officialCatalogFile, officialCapabilityAliases, resolvedFromHome, resolvedFromPrepared, teamEnv, isWorkspaceHome, preWorkspaceHome, isCapturedHome, capturedHomeRefusal, composeInstanceAgentsMd, parseYamlNested, withConfigFile,
+  findInstanceHome, findInstanceHomes, workspaceOf, stopInstanceSession, ensureRoot, findRoot, findAgent, findAgentAt, legacyLocalAgents, legacyCapturedHomes, listAgents, listInstances, servedIdentityLine, spawnInstanceAsync, instanceSoulDir, launchConfigsAt, explicitInstanceName, findModuleCapabilityAgent, capabilityAgentFromDir, retireInstance, inspectInstanceSession, inputInstanceSession, attachInstanceSession, startInstanceSession, defaultRepo, RELATIONS, validateLaunchConfig, renderLaunchRecipe, describeLaunchCommand, redactLaunchRecipe, LAUNCH_RUNTIMES, planLaunch, redactLaunchCommand, restartInstanceSession,
 } from "../lib/core.mjs";
 import {
-  assertNoSymlinkedParents, writeFileAtomic,
-  LOCK_FILE, readLock, writeLock, resolvePackages, approve as approvePackage,
-  classifyPackageValue, parsePackageRequest, executablesDigestAt } from "../lib/packages.mjs";
-import { loadLocal, discoverWorkspace, validateWorkspace } from "../lib/workspace.mjs";
+  writeFileAtomic, LOCK_FILE, readLock, writeLock, resolvePackages,
+  classifyPackageValue, parsePackageRequest } from "../lib/packages.mjs";
+import { loadLocal, validateWorkspace, validateLocal } from "../lib/workspace.mjs";
+import { parseConfigData } from "../lib/config-data.mjs";
 import * as remoteModule from "../lib/remote.mjs";
-import { createInterface } from "node:readline/promises";
 import YAML from "yaml";
 import { attachArgv, checkRemote, forgetSnapshot, getServer, inspectRemote, startRemote, restartRemote, launchConfigRemote, scheduleRemote, listSnapshots, readServers, rosterGroups, routeCommand, targetOf, validateServer, writeServers, SERVERS_FILE } from "../lib/servers.mjs";
 import { spawnSync as spawnSyncProc } from "node:child_process";
@@ -48,25 +41,16 @@ import { parseEnvelopeText, scheduleScopeOf, listSchedules, describe as describe
 import { hostUnitStatus, installHostUnit, uninstallHostUnit } from "../lib/schedule-host.mjs";
 import { receiveAttachment, uploadAttachment, readStreamBounded, MAX_ATTACHMENT_BYTES } from "../lib/attachments.mjs";
 
-import { capturedSelector } from "../lib/captured-selector.mjs";
-import { inspectCapturedPiOutcome } from "../lib/captured-pi-host.mjs";
-import { readCapturedResolution } from "../lib/captured-resolutions.mjs";
-import { oatsError } from "../lib/errors.mjs";
-import { canonicalJson } from "../lib/portable-values.mjs";
-import { readPortablePreparationRequest } from "../lib/portable-onboarding-request.mjs";
-import { portableScope } from "../lib/portable-state.mjs";
-import { CAPTURED_OPERATION_TIMEOUT_MS, runCapturedOperationProcess } from "../lib/captured-operation-process.mjs";
-import { approveCapturedCapability } from "../lib/artifact-approvals.mjs";
 import { observeInstanceGit, diffInstanceFile } from "../lib/instance-git.mjs";
 import { planStop, applyStop, planRetire, resolveInstance as resolveInstanceForCli } from "../lib/instance-lifecycle.mjs";
 const await_import_lifecycle = () => ({ resolveInstance: resolveInstanceForCli });
-import { readinessOf, policyOf } from "../lib/readiness.mjs";
+import { homeTarget, soulTarget, isWorkspaceContext, inspectDocument, readinessDocument, policyOf, policySoul, manifestMissingRequires, INSPECT_OPERATIONS_API } from "../lib/instance-inspect.mjs";
 import { readEvents } from "../lib/instance-events.mjs";
 
 const args = process.argv.slice(2);
 let cmd = args[0];
 const HELP_WORDS = new Set(["help", "--help", "-h"]);
-const KERNEL_COMMANDS = new Set(["prepare", "capture", "capabilities", "create", "doctor", "inspect", "instance", "operation", "package", "readiness", "soul", "souls", "launch-config", "experimental", "onboard", "pane", "recall", "retire", "root", "schedule", "server", "session", "setup", "spawn", "status", "sync", "type", "update", "version", "workspace"]);
+const KERNEL_COMMANDS = new Set(["capture", "capabilities", "doctor", "inspect", "instance", "operation", "package", "readiness", "souls", "launch-config", "experimental", "onboard", "pane", "recall", "retire", "root", "schedule", "server", "session", "setup", "spawn", "status", "sync", "update", "version", "workspace"]);
 const flag = (name) => {
   const i = args.indexOf(`--${name}`);
   return i >= 0 ? (args[i + 1] && !args[i + 1].startsWith("--") ? args[i + 1] : true) : undefined;
@@ -81,7 +65,7 @@ function valueFlag(name) {
   return value;
 }
 const die = (msg) => { console.error(`oats: ${msg}`); process.exit(1); };
-const cmdFail = (code, msg) => (JSON_MODE ? jsonFail(code, msg) : die(msg));
+const cmdFail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
 /** Resolve the --dir flag with central validation: a value-taking flag given
  * no value (flag() → true) is E_BAD_ARGS inside the JSON boundary, never an
  * uncaught resolve(true) TypeError (reviewer-6f0a3bd). */
@@ -104,382 +88,14 @@ const JSON_MODE = args.includes("--json");
 const CLI_BIN = realpathSync(fileURLToPath(import.meta.url));
 const jsonFail = (code, message, details) => { console.log(JSON.stringify({ schemaVersion: 1, ok: false, error: { code, message: String(message), ...(details !== undefined ? { details } : {}) } })); process.exit(1); };
 const jsonOk = (result) => { console.log(JSON.stringify({ schemaVersion: 1, ok: true, result })); };
-
-function inspectOnboardingCmd() {
-  const fail = (code, message) => JSON_MODE ? jsonFail(code, message) : die(message);
-  const values = new Map();
-  for (let index = 1; index < args.length; index++) {
-    if (args[index] === "--json") continue;
-    const key = args[index];
-    if (!["--request", "--emit-prepare-request"].includes(key) || values.has(key) || !args[index + 1] || args[index + 1].startsWith("--")) fail("E_BAD_ARGS", "source inspection accepts one --request <absolute-json>, optional --emit-prepare-request <new-absolute-json>, and --json");
-    values.set(key, args[++index]);
-  }
-  try {
-    const output = values.get("--emit-prepare-request");
-    let parent;
-    const checkOutput = () => {
-      if (!isAbsolute(output) || resolve(output) !== output || output.includes("\0")) throw oatsError("E_BAD_ARGS", "prepare-request output needs a normalized absolute path");
-      let stat;
-      try {
-        stat = lstatSync(dirname(output));
-        if (!stat.isDirectory() || realpathSync(dirname(output)) !== dirname(output)) throw new Error();
-      } catch { throw oatsError("E_BAD_ARGS", "prepare-request output parent must be an existing real directory"); }
-      if (parent && (parent.dev !== stat.dev || parent.ino !== stat.ino)) throw oatsError("selection-changed", "prepare-request output parent changed during inspection");
-      try { lstatSync(output); }
-      catch (error) { if (error.code === "ENOENT") return stat; throw oatsError("E_BAD_ARGS", "prepare-request output could not be checked"); }
-      throw oatsError("E_BAD_ARGS", "prepare-request output already exists; choose a new file (nothing overwritten)");
-    };
-    if (output !== undefined) parent = checkOutput();
-    const input = readPortablePreparationRequest({ file: values.get("--request") });
-    const { prepareRequest, ...view } = inspectPortableOnboarding(input, { includePrepareRequest: output !== undefined });
-    let result = view;
-    if (output !== undefined) {
-      checkOutput();
-      try { writeFileSync(output, canonicalJson(prepareRequest) + "\n", { flag: "wx", mode: 0o600 }); }
-      catch { throw oatsError("E_BAD_ARGS", "prepare-request output could not be created exclusively; no existing file was overwritten"); }
-      const deployment = view.deployment.deployment.path;
-      result = { ...view, prepareRequestFile: output, effects: { ...view.effects, requestFileWrite: true,
-        deploymentWrites: output === deployment || output.startsWith(deployment + sep) } };
-    }
-    if (JSON_MODE) jsonOk(result); else console.log(JSON.stringify(result, null, 2));
-  } catch (error) { fail(error.code || "E_INSPECT_FAILED", error.message); }
-}
-
-function prepareCmd() {
-  const fail = (code, message, details) => JSON_MODE ? jsonFail(code, message, details) : die(message);
-  const values = new Map(), allowed = new Set(["request", "dir", "source", "revision", "export", "alias", "workspace", "workspace-revision", "work"]);
-  for (let index = 1; index < args.length; index++) {
-    if (args[index] === "--json") continue;
-    const key = args[index].startsWith("--") ? args[index].slice(2) : "";
-    if (!allowed.has(key) || values.has(key) || !args[index + 1] || args[index + 1].startsWith("--")) fail("E_BAD_ARGS", "prepare needs unique named source/context arguments; use prepare --help");
-    values.set(key, args[++index]);
-  }
-  try {
-    let input;
-    if (values.has("request")) {
-      // The shared leaf owns request bytes/exclusivity; this router alone owns
-      // argv and has already refused explicit captured selectors.
-      input = readPortablePreparationRequest({ file: values.get("request"),
-        inputFlags: Object.fromEntries([...values].filter(([key]) => key !== "request")) });
-    } else {
-      const deployment = values.get("dir"), alias = values.get("alias"), source = values.get("source");
-      if (!deployment || !isAbsolute(deployment) || !alias) fail("E_BAD_ARGS", "prepare needs --dir <absolute deployment> and --alias <name>");
-      if (source ? !values.get("revision") || !values.get("export") : !values.get("workspace") || values.has("revision") || values.has("export")) fail("E_BAD_ARGS", "choose a complete source/revision/export reference or a workspace-advertised alias");
-      if (values.has("workspace-revision") && !values.has("workspace")) fail("E_BAD_ARGS", "--workspace-revision requires --workspace");
-      const origin = { kind: "operator", document: { kind: "operator", id: "oats-prepare" }, pointer: "/source" };
-      input = { deployment, source: source ? { source, revision: values.get("revision"), soul: values.get("export"), alias } : alias, origin,
-        ...(values.has("work") ? { mode: values.get("work") } : {}),
-        ...(values.has("workspace") ? { workspace: { source: values.get("workspace"), origin: { ...origin, pointer: "/workspace" },
-          ...(values.has("workspace-revision") ? { revision: values.get("workspace-revision") } : {}) } } : {}) };
-    }
-    // Pass the whole request to the one public validator/resolver. Unknown
-    // fields are refused there, never filtered or filled from ambient state.
-    const result = prepareCapturedComposition(input);
-    if (!result.resolution) {
-      const summary = "preparation is incomplete; no executable resolution was published";
-      const reasons = (result.problems ?? []).filter(p => p.key !== undefined || (p.slot && p.capability))
-        .map(p => `[${p.slot && p.capability ? `${p.capability}/${p.slot}` : p.code}] ${p.key === undefined ? "" : `${JSON.stringify(p.key)}: `}${p.message}`);
-      fail("needs-configuration", JSON_MODE ? summary : [summary, ...reasons].join("\n"), result);
-    }
-    if (JSON_MODE) jsonOk(result); else console.log(JSON.stringify(result, null, 2));
-  } catch (error) { fail(error.code || "E_PREPARE_FAILED", error.message); }
-}
-
-/** Run one provider operation from immutable captured authority. A home is an
- * explicit target only: its stored binding must name this exact record. */
-function capturedOperation(selector, load, bail) {
-  if (args[1] !== "run") bail("E_USAGE", "usage: oats operation run <layer>:<name> --deployment <abs> --resolution <id> [--home <abs>] [--arg k=v ...] [--retry-intent <saved-id>] [--json]");
-  const address = args[2], match = typeof address === "string" ? OPERATION_ADDRESS_RE.exec(address) : null;
-  if (!match) bail("E_BAD_ARGS", `operation address must be <layer>:<name> with layer one of ${LAYERS.join(", ")} (got ${JSON.stringify(address)})`);
-  const [, slot, name] = match, given = Object.create(null);
-  let home, retryExecutionId;
-  for (let index = 3; index < args.length; index++) {
-    const token = args[index];
-    if (token === "--json") continue;
-    if (token === "--home") {
-      const value = args[++index];
-      if (home !== undefined || !value || value.startsWith("--") || !isAbsolute(value)) bail("E_BAD_ARGS", "--home needs one absolute instance home");
-      home = resolve(value); continue;
-    }
-    if (token === "--retry-intent") {
-      const value = args[++index];
-      if (retryExecutionId !== undefined || !value || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(value)) bail("E_BAD_ARGS", "--retry-intent requires one saved executionId");
-      retryExecutionId = value; continue;
-    }
-    if (token === "--arg") {
-      const value = args[++index], eq = value?.indexOf("=") ?? -1;
-      if (eq < 1) bail("E_BAD_ARGS", "--arg expects name=value");
-      const key = value.slice(0, eq);
-      if (Object.hasOwn(given, key)) bail("E_BAD_ARGS", `duplicate operation arg ${JSON.stringify(key)}`);
-      given[key] = value.slice(eq + 1); continue;
-    }
-    bail("E_BAD_ARGS", `unsupported captured operation argument ${JSON.stringify(token)}`);
-  }
-  let meta;
-  if (home) {
-    const metaFile = join(home, "instance.json");
-    if (!existsSync(metaFile)) bail("E_SESSION_UNKNOWN", `${home} is not an OATS instance home (no instance.json)`);
-    try { meta = JSON.parse(readFileSync(metaFile, "utf8")); } catch (error) { bail("E_SESSION_UNKNOWN", `${metaFile}: ${error.message}`); }
-    if (!meta || typeof meta !== "object" || Array.isArray(meta) || typeof meta.instance !== "string" || !meta.instance) bail("E_SESSION_UNKNOWN", `${metaFile}: invalid instance metadata`);
-    const binding = meta.executionBinding;
-    if (!binding) bail("migration-required", `${home} has no captured executionBinding; current configuration was not used`);
-    if (binding.schemaVersion !== 1 || typeof binding.deployment !== "string" || !isAbsolute(binding.deployment)
-      || realOrResolved(binding.deployment) !== realOrResolved(selector.deployment)
-      || binding.resolution?.schemaVersion !== 1 || binding.resolution.id !== selector.resolution.id) {
-      bail("E_HOME_MISMATCH", `${home} is not bound to captured resolution ${selector.resolution.id} in ${selector.deployment}`);
-    }
-  }
-  // Inspect is static: validate target and arguments before the action load runs
-  // the provider's mutable readiness check.
-  const inspected = load({ kind: "inspect" }), providerId = inspected.record.bindings[slot]?.capability;
-  const provider = providerId ? inspected.manifests.get(providerId) : undefined;
-  if (!provider) bail("capability-not-selected", `no captured ${slot} provider is selected`);
-  const operation = manifestOperations(provider).find((entry) => entry.name === name);
-  if (!operation) bail("operation-not-found", "captured provider does not declare this operation");
-  if (operation.context === "home" && !meta) bail("E_OPERATION_UNAVAILABLE", `${address} runs in an instance home; pass --home <abs>`);
-  if (operation.context === "scope" && meta) bail("E_BAD_ARGS", `${address} is a scope operation and does not accept --home`);
-  const declared = new Map(operation.args.map((entry) => [entry.name, entry]));
-  for (const key of Object.keys(given)) if (!declared.has(key)) bail("E_BAD_ARGS", `${address} takes no arg ${JSON.stringify(key)} (declared: ${[...declared.keys()].join(", ") || "none"})`);
-  for (const entry of operation.args) if (entry.required && given[entry.name] === undefined) bail("E_BAD_ARGS", `${address} needs --arg ${entry.name}=<value>: ${entry.description || "required"}`);
-  const action = { kind: "operation", slot, name };
-  const argFlags = operation.args.flatMap((entry) => given[entry.name] === undefined ? [] : [entry.flag, given[entry.name]]), cwd = home || selector.deployment;
-  if (operation.kind === "action" && !home) bail("admission-required", "scope mutation has no qualified incarnation/admission path; use an instance-scoped operation");
-  if (retryExecutionId !== undefined && operation.kind !== "action") bail("E_BAD_ARGS", "read-only operations do not retry mutation intents");
-  const admission = operation.kind === "action" ? admitCapturedAction({ deployment: selector.deployment, resolution: selector.resolution, home, action, input: { arguments: argFlags },
-    ...(retryExecutionId !== undefined ? { retryExecutionId } : {}) }) : null;
-  let settlement;
-  const admittedBail = (code, message, details) => bail(code, message, { ...details, ...(admission ? { intent: admission.intent } : {}),
-    ...(settlement ? { settlement, unconfirmed: settlement.state === "unconfirmed" } : {}) });
-  if (admission?.replayed) {
-    settlement = { state: "completed", receipt: admission.receipt };
-    if (!admission.replayable) admittedBail("needs-configuration", "completed operation cannot replay its retained outcome");
-    finishOperation({ r: { status: 0, stdout: JSON.stringify(admission.receipt) }, bail: admittedBail, address, provider, op: operation, argFlags, cwd, home, meta, intent: admission.intent }); return;
-  }
-  let loaded;
-  try { loaded = load(action, { invocationTarget: meta ? { home, work: join(home, "work"), name: meta.instance, agent: meta.agent } : null,
-    ...(admission ? { intent: admission.intent, priorReceipt: admission.receipt } : {}) }); }
-  catch (error) {
-    if (admission) {
-      settleCapturedIntent({ deployment: selector.deployment, home, intent: admission.intent, action, state: "blocked", receipt: admission.receipt });
-      settlement = { state: "blocked", receipt: admission.receipt };
-    }
-    admittedBail(error.code || "provider-unavailable", error.message);
-  }
-  const { capability, executable } = loaded;
-  const env = { ...process.env };
-  for (const key of Object.keys(env)) if (key.startsWith("OATS_") || key.startsWith("PI_AGENT_") || key === "PI_AGENTS_ROOT") delete env[key];
-  Object.assign(env, {
-    OATS_DEPLOYMENT: selector.deployment, OATS_RESOLUTION: selector.resolution.id,
-    OATS_CAPABILITY: capability.id, OATS_CAPABILITY_ROOT: capability.manifest._dir,
-    OATS_SETTINGS: JSON.stringify(capability.settings), OATS_CLI_BIN: CLI_BIN,
-    OATS_OPERATION: address, OATS_CONTEXT: selector.deployment, OATS_LEVEL: selector.deployment,
-    OATS_WORKSPACE: selector.deployment,
-  });
-  if (meta) Object.assign(env, { OATS_INSTANCE: meta.instance, OATS_INSTANCE_HOME: home, OATS_HOME: home,
-    PI_AGENT_INSTANCE: meta.instance, PI_AGENT_HOME: home, ...(meta.agent ? { OATS_AGENT: meta.agent } : {}) });
-  const invocation = loaded.invocation;
-  let child, cleanupError, started = false;
-  try {
-    child = withCapturedInvocationContextFile(invocation, contextEnv => withCapturedBindingFile(loaded, bindingEnv => {
-      if (admission) { beginCapturedIntent({ deployment: selector.deployment, home, intent: admission.intent, action }); started = true; }
-      return runCapturedOperationProcess({ file: executable.file, args: [...executable.args, ...argFlags, "--json"], cwd, env: { ...env, ...contextEnv, ...bindingEnv } });
-    }));
-  } catch (error) {
-    if (!error?.invocationCompleted) {
-      if (admission) {
-        settleCapturedIntent({ deployment: selector.deployment, home, intent: admission.intent, action, state: started ? "unconfirmed" : "blocked", receipt: admission.receipt });
-        settlement = { state: started ? "unconfirmed" : "blocked", receipt: admission.receipt };
-      }
-      admittedBail(error.code || "E_OPERATION_RESULT", error.message, { unconfirmed: started });
-    }
-    child = error.invocationResult; cleanupError = error;
-  }
-  if (admission) {
-    let envelope; try { envelope = JSON.parse(String(child.stdout || "").trim()); } catch { /* unconfirmed below */ }
-    const completed = !cleanupError && !child.error && child.status === 0 && envelope?.schemaVersion === 1 && envelope.ok === true;
-    const state = completed ? "completed" : "unconfirmed", receipt = envelope ?? parseEnvelopeText(String(child.stdout || "")) ?? admission.receipt;
-    try {
-      settleCapturedIntent({ deployment: selector.deployment, home, intent: admission.intent, action, state, receipt, replayable: completed });
-      settlement = { state, receipt };
-    }
-    catch (error) { admittedBail("E_OPERATION_RESULT", "operation ran but outcome custody could not be confirmed", { unconfirmed: true, envelope, custody: { code: error.code, message: error.message } }); }
-  }
-  finishOperation({ r: child, bail: admittedBail, address, provider: capability.manifest, op: operation, argFlags, cwd, home, meta, cleanupError, settlement, ...(admission ? { intent: admission.intent } : {}) });
-}
-
-/** Fresh explicit captured scaffold + spawn hooks. Placement is supplied by
- * the operator; launch and non-directory work remain unsupported. */
-function capturedSpawn(selector, load, bail) {
-  const subject = args[1]; let home; let noLaunch = false;
-  if (!subject || subject.startsWith("-")) bail("E_BAD_ARGS", "captured spawn needs the retained subject name");
-  for (let index = 2; index < args.length; index++) {
-    const token = args[index];
-    if (token === "--json") continue;
-    if (token === "--no-launch") { if (noLaunch) bail("E_BAD_ARGS", "duplicate --no-launch"); noLaunch = true; continue; }
-    if (token === "--home") {
-      const value = args[++index];
-      if (home !== undefined || !value || value.startsWith("--") || !isAbsolute(value)) bail("E_BAD_ARGS", "--home needs one absolute new instance home");
-      home = resolve(value); continue;
-    }
-    bail("E_BAD_ARGS", `unsupported captured spawn argument ${JSON.stringify(token)}`);
-  }
-  if (!home || !noLaunch) bail("E_BAD_ARGS", "captured spawn currently requires --home <absolute new home> and --no-launch");
-  const inspected = load({ kind: "inspect" }), expected = inspected.record.subject.kind === "persistent" ? inspected.record.subject.soul.alias : inspected.record.subject.name;
-  if (subject !== expected) bail("E_HOME_MISMATCH", `captured resolution subject is ${expected}, not ${subject}`);
-  const scaffold = scaffoldCapturedInstance({ deployment: selector.deployment, resolution: selector.resolution, home, instance: basename(home) });
-  let activated;
-  try {
-    activated = activateCapturedScaffold({ deployment: selector.deployment, resolution: selector.resolution, home,
-      extraEnv: process.env.OATS_HOME_DIR ? { OATS_HOME_DIR: process.env.OATS_HOME_DIR } : {} });
-  } catch (error) {
-    if (error?.home) bail(error.code || "E_SPAWN_FAILED", error.message, { home: error.home, cleanupRequired: true, failures: error.provenance || [],
-      ...(error.capturedCustody ? { unconfirmed: true, custody: error.capturedCustody } : {}) });
-    throw error;
-  }
-  const result = { ...scaffold, hooksPending: activated.hooksPending, cleanupRequired: activated.cleanupRequired, launchPending: true,
-    hookIntents: activated.hooks.intents, hookOrder: activated.hooks.order, warnings: activated.hooks.warnings };
-  if (JSON_MODE) jsonOk(result); else console.log(`Scaffolded ${result.instance} at ${result.home}; ${result.hooksPending ? "captured hook custody requires retry/reconciliation" : "captured hooks complete"}, launch pending`);
-}
-
-/** Native continuation of an already owned captured home. A helper selector is
- * an exact edge from the SOURCE record, not a name/current-config resolver. */
-function capturedSession(selector, bail) {
-  const inspecting = args[1] === "inspect";
-  if (!["start", "restart", "inspect"].includes(args[1])) bail("unsupported-action", "captured session supports start/restart or explicit Pi outcome inspect; no current-context fallback was used");
-  const values = new Map(), allowed = new Set(inspecting ? ["home", "helper", "native-record"] : ["home", "helper", "request", "retry-intent"]);
-  for (let index = 2; index < args.length; index++) {
-    if (args[index] === "--json") continue;
-    const key = args[index].startsWith("--") ? args[index].slice(2) : "", value = args[index + 1];
-    if (!allowed.has(key) || values.has(key) || !value || value.startsWith("--")) bail("E_BAD_ARGS", "captured session needs unique named home/helper/request/retry arguments");
-    values.set(key, value); index++;
-  }
-  const home = values.get("home"), retry = values.get("retry-intent");
-  if (!home || !isAbsolute(home) || resolve(home) !== home || home.includes("\0")) bail("E_BAD_ARGS", "captured session needs a normalized absolute --home");
-  if (retry !== undefined && !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(retry)) bail("E_BAD_ARGS", "--retry-intent requires one saved executionId");
-  if (inspecting && !/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(values.get("native-record") ?? "")) bail("E_BAD_ARGS", "captured Pi outcome inspect requires one explicit --native-record UUID");
-  const sourceExecutionBinding = { schemaVersion: 1, deployment: portableScope(selector.deployment), resolution: selector.resolution };
-  // Pure retained-subject check, before request files, provider or native calls.
-  // Dedicated helper IDs remain valid for scaffolding, not edge-less dispatch.
-  if (!values.has("helper") && readCapturedResolution(sourceExecutionBinding.deployment, sourceExecutionBinding.resolution).subject.kind === "helper") {
-    bail("helper-not-selected", "captured helper session needs SOURCE selectors plus --helper EXACT_SOURCE_HELPER_KEY");
-  }
-  // Reuse the same bounded strict object-file transport. Preparation and native
-  // request schemas remain separate; reject unknown fields before projection.
-  let request = {};
-  if (values.has("request")) {
-    const input = readPortablePreparationRequest({ file: values.get("request") });
-    if (input.schemaVersion !== 1 || Object.keys(input).some(key => !["schemaVersion", "backend", "task", "stopGraceMs"].includes(key))) bail("E_BAD_ARGS", "native request must be version1 with only backend/task/stopGraceMs");
-    if (Object.hasOwn(input, "backend") && (!input.backend || typeof input.backend !== "object" || Array.isArray(input.backend))) bail("E_BAD_ARGS", "a supplied native backend must be an explicit object, not omission");
-    const { schemaVersion, ...fields } = input; request = fields;
-  }
-  const helperSelection = values.has("helper") ? resolveCapturedHelper({ executionBinding: sourceExecutionBinding, helper: values.get("helper") }) : null;
-  const executionBinding = helperSelection?.executionBinding ?? sourceExecutionBinding;
-  try {
-    if (inspecting) {
-      const outcome = inspectCapturedPiOutcome(home, { ...executionBinding, nativeRecordId: values.get("native-record") });
-      const result = { outcome, executionBinding, ...(helperSelection ? { sourceExecutionBinding: helperSelection.sourceExecutionBinding, helper: helperSelection.helper } : {}) };
-      if (JSON_MODE) jsonOk(result); else console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    const native = startCapturedInstanceSession(home, { ...request, deployment: executionBinding.deployment, resolution: executionBinding.resolution,
-      restart: args[1] === "restart", ...(retry !== undefined ? { retryExecutionId: retry } : {}) });
-    const result = { ...native, executionBinding, ...(helperSelection ? { sourceExecutionBinding: helperSelection.sourceExecutionBinding, helper: helperSelection.helper } : {}) };
-    if (JSON_MODE) jsonOk(result); else console.log(`${result.replayed ? "Replayed captured dispatch receipt for" : "Dispatched captured native session for"} ${home}`);
-  } catch (error) {
-    bail(error.code || "E_SESSION_START_FAILED", error.message, { home: error.home ?? home, executionBinding,
-      ...(helperSelection ? { sourceExecutionBinding: helperSelection.sourceExecutionBinding, helper: helperSelection.helper } : {}),
-      ...(error.capturedCustody ? { custody: error.capturedCustody } : {}),
-      ...(error.nativeCustody ? { unconfirmed: true, nativeCustody: error.nativeCustody } : {}) });
-  }
-}
-
-/** Exact-selector dispatch enters before any current-context resolver. Its
- * child receives the same selector, never an invoking agent's ambient identity. */
-function capturedCommand(selector) {
-  const fail = (code, message, details) => JSON_MODE ? jsonFail(code, message, details) : die(message);
-  try {
-    const end = args.indexOf("--"), head = end < 0 ? args : args.slice(0, end);
-    const permitsHome = cmd === "operation" || cmd === "spawn" || cmd === "session";
-    const forbiddenContext = permitsHome ? ["--dir", "--server", "--soul", "--agents-root"] : ["--dir", "--home", "--server", "--soul", "--agents-root"];
-    if (head.some((arg) => forbiddenContext.includes(arg.split("=")[0]))) {
-      fail("E_BAD_ARGS", "captured selectors cannot be mixed with current-context selectors");
-    }
-    if (selector.artifactSet !== undefined) {
-      if (cmd !== "trust" || !args[1] || args[1].startsWith("-") || args.slice(2).some((arg) => arg !== "--json")) fail("E_BAD_ARGS", "artifact-set selectors support only explicit trust of one capability");
-      const result = approveAvailableCapability(selector.deployment, selector.artifactSet, args[1], {
-        kind: "operator", document: { kind: "operator", id: "oats-trust-artifact-set" }, pointer: "/capability",
-      });
-      if (JSON_MODE) jsonOk(result); else console.log(`${args[1]}: ${result.status}`);
-      return;
-    }
-    const target = { deployment: selector.deployment, resolution: selector.resolution };
-    const load = (action, extra = {}) => loadCapturedDispatch({ ...target, action, ...extra });
-    if (cmd === "inspect") {
-      let helperKey;
-      for (let index = 1; index < args.length; index++) {
-        if (["--json", "--composition"].includes(args[index])) continue;
-        if (args[index] !== "--helper" || helperKey !== undefined || !args[index + 1] || args[index + 1].startsWith("--")) fail("E_BAD_ARGS", "captured inspect accepts --json, --composition and one --helper <exact-map-key>");
-        helperKey = args[++index];
-      }
-      const helperSelection = helperKey === undefined ? null : resolveCapturedHelper({ executionBinding: { schemaVersion: 1, ...target }, helper: helperKey });
-      const selected = helperSelection?.executionBinding ?? target;
-      const loaded = loadCapturedDispatch({ deployment: selected.deployment, resolution: selected.resolution, action: { kind: args.includes("--composition") ? "compose" : "inspect" } });
-      const result = { resolution: loaded.resolution, capture: loaded.record.capture, nativeSession: capturedNativeSessionAvailability(),
-        launchSelection: loaded.record.dispatch.launch === null ? null : {
-          runtime: loaded.record.dispatch.launch.runtime, model: loaded.record.dispatch.launch.model,
-        },
-        ...(helperSelection ? { helperSelection } : {}),
-        capabilities: [...loaded.capabilities.values()].map(({ id, manifest }) => ({ id, version: manifest.version,
-          approval: loaded.approvals.find((entry) => entry.artifact.capability === id).status })),
-        helpers: Object.entries(loaded.record.helpers).map(([key, resolution]) => ({ key, resolution })),
-        hasComposition: !!loaded.record.dispatch.composition,
-        ...(loaded.composition ? { composition: loaded.composition } : {}) };
-      if (JSON_MODE) jsonOk(result); else console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    if (cmd === "trust") {
-      if (!args[1] || args[1].startsWith("-") || args.slice(2).some((arg) => arg !== "--json")) fail("E_BAD_ARGS", "captured trust needs one capability ID");
-      load({ kind: "inspect" }); // complete manifest validation before approval
-      const result = approveCapturedCapability(selector.deployment, selector.resolution, args[1], {
-        kind: "operator", document: { kind: "operator", id: "oats-trust" }, pointer: "/capability",
-      });
-      if (JSON_MODE) jsonOk(result); else console.log(`${args[1]}: ${result.status}`);
-      return;
-    }
-    if (cmd === "operation") { capturedOperation(selector, load, fail); return; }
-    if (cmd === "spawn") { capturedSpawn(selector, load, fail); return; }
-    if (cmd === "session") { capturedSession(selector, fail); return; }
-    if (!cmd || cmd.startsWith("-") || KERNEL_COMMANDS.has(cmd)) fail("unsupported-action", "this kernel command has not yet adopted captured selectors; no current-context fallback was used");
-    if (!args[1] || args[1] === "--json" || head.some((arg) => HELP_WORDS.has(arg))) {
-      const loaded = load({ kind: "inspect" });
-      const matches = [...loaded.manifests.values()].filter((manifest) => manifest.command === cmd);
-      if (matches.length !== 1) fail("capability-not-selected", "captured command namespace is absent or ambiguous");
-      const result = { capability: matches[0].capability, commands: Object.keys(matches[0].commands || {}), help: "manifest only; no executable ran" };
-      if (JSON_MODE) jsonOk(result); else console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    const loaded = load({ kind: "command", namespace: cmd, name: args[1] });
-    const env = { ...process.env };
-    for (const key of Object.keys(env)) if (key.startsWith("OATS_") || key.startsWith("PI_AGENT_") || key === "PI_AGENTS_ROOT") delete env[key];
-    Object.assign(env, { OATS_DEPLOYMENT: selector.deployment, OATS_RESOLUTION: selector.resolution.id,
-      OATS_CAPABILITY: loaded.capability.id, OATS_CAPABILITY_ROOT: loaded.capability.manifest._dir,
-      OATS_SETTINGS: JSON.stringify(loaded.capability.settings),
-      OATS_CLI_BIN: CLI_BIN, OATS_CONTEXT: selector.deployment, OATS_LEVEL: selector.deployment });
-    const forwarded = args.slice(2); if (forwarded[0] === "--") forwarded.shift();
-    const child = withCapturedInvocationContextFile(loaded.invocation, contextEnv => withCapturedBindingFile(loaded, bindingEnv => spawnSync(process.execPath, [loaded.executable.file, ...loaded.executable.args, ...forwarded], {
-      cwd: selector.deployment, env: { ...env, ...contextEnv, ...bindingEnv }, stdio: "inherit",
-    })));
-    if (child.error) fail("E_CAPABILITY_BROKEN", child.error.message);
-    process.exit(child.status ?? 1);
-  } catch (error) { fail(error.code || "E_CAPABILITY_BROKEN", error.message); }
-}
-
-/** Level of a directory: laptop (home), repo (.git), else workspace. */
-function levelOf(dir) {
-  const d = resolve(dir);
-  if (d === homedir()) return "laptop";
-  if (existsSync(join(d, ".git"))) return "repo";
-  return "workspace";
+const formatBytes = (n) => n < 1024 ? `${n} B` : n < 1024 ** 2 ? `${(n / 1024).toFixed(1)} KiB` : n < 1024 ** 3 ? `${(n / 1024 ** 2).toFixed(1)} MiB` : `${(n / 1024 ** 3).toFixed(1)} GiB`;
+/** A retire recovery's copied outputs (untracked/ignored or directory work), named with their size. */
+function preservedOutputLines(recovery) {
+  const outputs = recovery?.outputs;
+  if (!outputs?.paths?.length) return [];
+  const shown = outputs.paths.slice(0, 8).map((p) => `${p.path} (${formatBytes(p.bytes)})`);
+  const more = outputs.paths.length > 8 ? `, and ${outputs.paths.length - 8} more` : "";
+  return [`  copied outputs: ${shown.join(", ")}${more} — ${formatBytes(outputs.bytes)} in total`];
 }
 
 function shortPath(p) {
@@ -493,56 +109,63 @@ function shellQuote(s) {
   return /^[A-Za-z0-9._/~-]+$/.test(s) ? s : `'${String(s).replace(/'/g, `'\\''`)}'`;
 }
 
-/** The scaffolded `name:` value — the target directory's basename — held to the
- * SAME write refusal as every other value this CLI renders into a config line.
- *
- * A basename is filesystem input, not a literal: a directory whose name embeds
- * a newline turned one scaffolded `name:` line into arbitrary top-level config
- * blocks (a live `team:` block smuggled through `oats init`), and a `#`-leading
- * basename wrote a value that reads back as an empty map. Refusing names the
- * offending basename and writes nothing — the operator renames the directory. */
-function scaffoldConfigName(dir) {
-  return assertSafeConfigValue(basename(dir), `the scaffolded name from the directory basename ${JSON.stringify(basename(dir))}`);
-}
 
 // ---------- doctor ----------
 /** Doctor must diagnose, not crash: a stale activation of a retired
  * capability fails config resolution — surface the cleanup instruction
  * cleanly (text or JSON) instead of an uncaught stack trace. */
-function resolveForDoctor(ctx, soulName, { json } = {}) {
-  try { return resolveOatsConfig(ctx, soulName); }
-  catch (e) {
-    // Doctor is THE diagnosis surface: it alone catches the typed fail-closed
-    // invalid-lock error and continues to render actionable state.
-    if (e.code === "invalid-lock") {
-      const prov = Array.isArray(e.provenance) ? e.provenance[0] : undefined;
-      if (json) { console.log(JSON.stringify({ context: ctx, error: { code: "invalid-lock", message: e.message, provenance: e.provenance || null } }, null, 2)); process.exit(1); }
-      console.log(`oats doctor — resolved from ${shortPath(ctx)}\n`);
-      console.log(`ERROR: ${e.message} [invalid-lock]`);
-      if (prov?.file) console.log(`  fix or remove the offending entry in ${shortPath(prov.file)} — the lock is never auto-repaired; all package operations fail closed until it is valid`);
-      process.exit(0); // doctor DIAGNOSED successfully; the lock is the problem
-    }
-    const retiredId = Object.keys(RETIRED_CAPABILITIES).find((id) => String(e.message).includes(`"${id}"`) && String(e.message).includes("retired"));
-    if (!retiredId) throw e;
-    if (json) { console.log(JSON.stringify({ schemaVersion: 1, context: ctx, error: e.message, retired: [retiredId] }, null, 2)); process.exit(1); }
-    die(`${e.message}`);
-  }
-}
 function operationalKnowledgeNote(composition, soulName) {
   return composition && !composition.oatsCoreDeclared
-    ? `soul ${soulName} has no oats.core capability; kernel-shipped operational skills are deprecated` : null;
-}
-function doctorComposition(ctx, soulName) {
+    ? `soul ${soulName} has no oats.core capability (the workspace default); it gets no OATS operating instructions` : null;
+}
+/** `doctor --soul`: the instructions an instance of that soul would carry. The soul
+ *  is resolved over the workspace remotes exactly as a spawn preview resolves it,
+ *  the kernel half composed, and the modules materialized into a scratch home
+ *  OUTSIDE the deployment (removed after), so module injects are part of the text.
+ *  Nothing in the deployment is written. Block files of module injects are named
+ *  home-relative (`.oats/modules/<cap>/<inject>`), where an instance carries them. */
+async function doctorComposition(ctx, soulName, ws, bail) {
   if (!soulName) return undefined;
-  const root = findRoot(ctx);
-  const agent = root && findAgent(root, soulName);
-  if (!agent) throw new Error(`unknown soul "${soulName}" for doctor composition`);
-  return composeInstanceAgentsMd(join(agent._dir, "soul"), ctx, agent.name, agent.work || "checkout", agent.kind);
+  const { prepareInstance, previewWorkspaceSoul, materializePrepared, discoverOrStandalone } = await import("../lib/instance-resolution.mjs");
+  const deployment = dirname(ws.local.path);
+  const root = join(deployment, "agents");
+  const remoteOptions = remoteOptionsFromEnv();
+  const cleanups = [];
+  // A bail exits the process without unwinding: the temporary copies are removed at exit too.
+  process.once("exit", () => { for (const c of cleanups) { try { c(); } catch { /* best effort */ } } });
+  try {
+    const discovery = await discoverOrStandalone(loadLocal(deployment).local, { remoteOptions });
+    const prepared = await prepareInstance(deployment, soulName, { remoteOptions, discovery });
+    const pv = await previewWorkspaceSoul(prepared, root);
+    cleanups.push(pv.cleanup);
+    const agent = findAgentAt(root, prepared.soulEntry.name, pv.soulDir);
+    if (!agent) bail("E_SOUL_UNKNOWN", `soul "${soulName}" was fetched but is not readable as a soul`);
+    const composition = composeInstanceAgentsMd(pv.soulDir, deployment, agent.name, agent.work || "checkout", agent.kind, prepared);
+    const scratch = realpathSync(mkdtempSync(join(tmpdir(), "oats-doctor-home-")));
+    cleanups.push(() => rmSync(scratch, { recursive: true, force: true }));
+    const outcome = await materializePrepared({ ...prepared, soulAgentsMd: composition.text, soulDir: pv.soulDir }, scratch);
+    const text = readFileSync(join(scratch, "AGENTS.md"), "utf8");
+    const known = new Set(composition.blocks.map((b) => b.source));
+    const outcomeBlocks = Array.isArray(outcome?.blocks) ? outcome.blocks : [];
+    for (const m of text.matchAll(/^<!-- oats:(capability:[^\s]+) src=(.+?) -->$/gm)) {
+      const [, source, file] = m;
+      if (known.has(source)) continue;
+      known.add(source);
+      const content = outcomeBlocks.find((b) => b.source === source && b.file === file)?.content ?? (existsSync(file) ? readFileSync(file, "utf8").trim() : "");
+      const rel = file.startsWith(scratch + sep) ? file.slice(scratch.length + 1) : file;
+      composition.blocks.push({ source, file: rel, content, materialized: true });
+    }
+    return { ...composition, text };
+  } catch (e) {
+    if (e?.code?.startsWith?.("E_")) bail(e.code, e.message, e.details);
+    throw e;
+  } finally { for (const c of cleanups) { try { c(); } catch { /* best effort: temporary copies only */ } } }
 }
 
 /** Workspace-model v2 doctor data, OFFLINE: the deployment declaration found
  * walking up from ctx (oats-local.yaml) and the lock v3 beside it. Doctor never
- * goes to the network; membership and discovery are `oats sync` / `oats workspace status`. */
+ * goes to the network for this view (only `--soul`, which resolves the soul like a
+ * spawn preview); membership and discovery are `oats sync` / `oats workspace status`. */
 function doctorLockData(ctx) {
   const out = { local: null, localError: null, lockFile: null, packages: [], lockError: null };
   let lockDir = ctx;
@@ -551,7 +174,9 @@ function doctorLockData(ctx) {
     out.local = { path: found.path, workspace: found.local.workspace };
     lockDir = dirname(found.path);
   } catch (e) {
-    if (e?.code === "E_WORKSPACE_SCHEMA") out.localError = { code: e.code, message: e.message };
+    // An unreadable oats-local.yaml, or a 0.25 oats-config.yaml inside the deployment
+    // (E_CONFIG_BROKEN reason legacy-config): doctor answers it as its typed error.
+    if (e?.code === "E_WORKSPACE_SCHEMA" || e?.code === "E_CONFIG_BROKEN") out.localError = { code: e.code, message: e.message, details: e.details };
     else if (e?.code !== "E_LOCAL_MISSING") throw e;
   }
   const file = join(lockDir, LOCK_FILE);
@@ -559,7 +184,7 @@ function doctorLockData(ctx) {
   out.lockFile = file;
   try {
     const lock = readLock(lockDir);
-    out.packages = Object.entries(lock.packages).map(([id, p]) => ({ id, version: p.version, source: p.source, path: p.path, commit: p.commit, integrity: p.integrity, capabilities: p.capabilities, approved: p.approved }));
+    out.packages = Object.entries(lock.packages).map(([id, p]) => ({ id, version: p.version, source: p.source, path: p.path, commit: p.commit, integrity: p.integrity, capabilities: p.capabilities }));
   } catch (e) {
     if (e?.code !== "E_LOCK_SCHEMA") throw e;
     out.lockError = { code: e.code, message: e.message, file: e.details?.file ?? file };
@@ -567,45 +192,6 @@ function doctorLockData(ctx) {
   return out;
 }
 
-/** The health of ONE materialized capability, against the rows it was projected
- * from. Shared by doctor and list so both name the same states with the same
- * codes — and so the `.oats-installation.json` provenance is checked in BOTH,
- * not only deep inside trust resolution where it surfaces as a bare "untrusted".
- *
- * Order matters: a missing artifact cannot be hashed, drifted bytes make an
- * approval meaningless (so trust is not ALSO reported), and provenance is only
- * worth reading once the bytes are the locked ones. */
-/** The lock rows AT one level. Never the merged maps: those resolve each
- * identity independently, so an outer scope's capability can be paired with a
- * nearer scope's package of the same id — a provider that never exported it. */
-const levelRows = (locks, level) => locks.levels.find((l) => l.level === level) || { packages: Object.create(null), capabilities: Object.create(null) };
-
-/** A capability has an executable surface when its manifest declares commands,
- *  hooks or launch environment — the things `oats trust` approves. A
- *  data-only capability (skills/injects) has none, and trust is not-applicable. */
-function hasExecutableSurface(manifest) {
-  return !!(Object.keys(manifest?.commands || {}).length || Object.keys(manifest?.hooks || {}).length || (manifest?.environment?.length || 0));
-}
-function capabilityHealth(level, cap, capRow, pkgRow) {
-  const dir = installedCapabilityDir(level, cap.id);
-  if (!cap.installed) return { status: "missing", code: "missing-capability-artifact", dir, detail: `capability ${cap.id} is locked but not materialized — run \`oats sync\` to re-materialize it` };
-  let integrity;
-  try { integrity = capabilityArtifactIntegrity(dir); }
-  catch (e) { return { status: "broken", code: e.code || "invalid-capability-artifact", dir, detail: `capability ${cap.id}: ${e.message}` }; }
-  if (integrity !== cap.integrity) {
-    return { status: "drifted", code: "integrity-drift", dir, integrity, detail: `capability ${cap.id}: artifact integrity drift — installed ${integrity}, locked ${cap.integrity}; its executable approval is invalid` };
-  }
-  // The artifact's own provenance and the lock must tell the SAME story before
-  // either is believed. Neither silently wins; the disagreement is the finding.
-  if (capRow && pkgRow) {
-    try { verifyCapabilityInstallation(dir, cap.id, capRow, pkgRow); }
-    catch (e) { return { status: "provenance-mismatch", code: e.code || "invalid-lock", dir, integrity, detail: `capability ${cap.id}: ${e.message}` }; }
-  }
-  const executable = hasExecutableSurface(cap.manifest);
-  if (executable && !cap.trusted) return { status: "untrusted", code: "untrusted-surface", dir, integrity, detail: `capability ${cap.id}: executable surface UNTRUSTED — approve it in \`oats sync\`` };
-  return { status: "ok", code: null, dir, integrity, detail: null };
-}
-
 // ---------- inspect: one authoritative answer for GUIs ----------
 /** Souls, capabilities (installed state and health, separately from
  *  activation), effective layer bindings and declared operations for a
@@ -614,35 +200,19 @@ function capabilityHealth(level, cap, capRow, pkgRow) {
  *  from its roster poll). Nothing here is provider-specific: what a
  *  knowledge provider offers is what its manifest declares. */
 const INSPECT_TEXT_CAP = 256 * 1024;
-function readTextCapped(file) {
-  let bytes;
-  try { bytes = readFileSync(file); }
-  catch (e) { return { file, text: null, sha256: null, truncated: false, error: `${e.code || "EIO"}: ${e.message}` }; }
-  const truncated = bytes.length > INSPECT_TEXT_CAP;
-  // The bound is bytes; a cut inside a multi-byte sequence is dropped, never
-  // rendered as a replacement character.
-  let text = truncated ? bytes.subarray(0, INSPECT_TEXT_CAP).toString("utf8") : bytes.toString("utf8");
-  if (truncated && text.endsWith("\uFFFD")) text = text.slice(0, -1);
-  return { file, text, sha256: createHash("sha256").update(bytes).digest("hex"), bytes: bytes.length, truncated, error: null };
-}
-/** The canonical agents root a home belongs to, from its path alone:
- *  <root>/<agent>/instances/<instance>, or <workspace>/local-agents/<agent>/
- *  instances/<instance> whose canonical root is the sibling agents/. */
-function agentsRootOfHome(home) {
-  const agentDir = dirname(dirname(home));
-  const base = dirname(agentDir);
-  return basename(base) === "local-agents" ? join(dirname(base), "agents") : base;
-}
+/** The agents root a home belongs to, from its path alone:
+ *  <root>/<agent>/instances/<instance>. */
+function agentsRootOfHome(home) { return dirname(dirname(dirname(home))); }
 const SOUL_FIELDS = ["runtime", "model", "yolo", "backend", "description", "launch-config"];
 const realOrResolved = (p) => { try { return realpathSync(p); } catch { return resolve(p); } };
-/** Every soul of a scope: persistent and local souls of every agents root in
+/** Every soul of a scope: the persistent souls of every agents root in
  *  scope, plus packaged souls (read-only). One enumeration for inspect and
  *  operation run, so both address souls the same way. */
-function scopeSouls(ctx, r, { extraRoots = [] } = {}) {
+function scopeSouls(ctx, { extraRoots = [] } = {}) {
   // A home's own agents root is always in scope for that home: its recorded
   // work repository may be another repository entirely (repo overrides), and
   // the config context resolves there while the soul lives with its owner.
-  const roots = [...new Set([...(r.team ? teamAgentRoots(r.team.scope) : [findRoot(ctx)]), ...extraRoots].filter(Boolean).map((p) => realOrResolved(resolve(p))))];
+  const roots = [...new Set([findRoot(ctx), ...extraRoots].filter(Boolean).map((p) => realOrResolved(resolve(p))))];
   const souls = [];
   for (const root of roots) {
     for (const a of listInstances(root)) {
@@ -652,17 +222,7 @@ function scopeSouls(ctx, r, { extraRoots = [] } = {}) {
       souls.push(e);
     }
   }
-  const diagnostics = [];
-  try {
-    const packaged = listCapabilityAgents(ctx);
-    diagnostics.push(...(packaged.diagnostics || []));
-    for (const pa of packaged) {
-      let soul = {};
-      try { soul = stripInternalAnnotations(withConfigFile(join(pa.soulDir, "soul.yaml"), () => parseYamlNested(readFileSync(join(pa.soulDir, "soul.yaml"), "utf8")))); } catch { /* reported by name only */ }
-      souls.push(soulEntry({ ...soul, name: pa.name, description: pa.description ?? soul.description, soulDir: pa.soulDir }, roots[0] || ctx, { capability: pa.capability }));
-    }
-  } catch (e) { diagnostics.push({ code: e.code || "E_CAPABILITY_BROKEN", message: e.message }); }
-  return { roots, souls, diagnostics };
+  return { roots, souls, diagnostics: [] };
 }
 /** The one soul a name (and optional agents root) addresses; throws with a
  *  code when none or several match. */
@@ -745,215 +305,71 @@ function soulEntry(soul, root, { capability } = {}) {
  *  invoking process's ambient agents-root override must not redirect them
  *  to its own deployment. */
 function dropAmbientRoot() { delete process.env.PI_AGENTS_ROOT; }
-function inspectCmd() { const result = computeInspect(); if (!result) return; if (JSON_MODE) { const { _print, ...data } = result; jsonOk(data); return; } printInspect(result); }
-/** The inspect answer as data — shared by `oats inspect` and `oats readiness`
- *  (K5), so the readiness quartet is derived from the SAME capability,
- *  activation, trust and soul facts inspect reports, never a second opinion. */
-function computeInspect({ onFail } = {}) {
-  const bail = onFail || ((code, msg) => (JSON_MODE ? jsonFail(code, msg) : die(msg)));
+async function inspectCmd() {
+  const bail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
+  const t = await workspaceTarget(bail, { command: "inspect" });
+  if (t) {
+    if (t.resolutionError) return bail(t.resolutionError.code, t.resolutionError.message, t.resolutionError.details ?? undefined);
+    const doc = inspectDocument(t, { kernel: OATS_VERSION });
+    if (JSON_MODE) { jsonOk(doc); return; }
+    printWorkspaceInspect(doc); return;
+  }
+}
+/** The workspace-model target of inspect / readiness / operation run (lead
+ *  decision 4): an instance home with materialized modules (`--home`), or a soul
+ *  of a workspace deployment (`--soul`, resolved as its spawn would be). Anything
+ *  else is a typed refusal: there is no classic scope answer. */
+async function workspaceTarget(bail, { command, liveTeams = true }) {
   dropAmbientRoot();
-  const homeFlag = flag("home");
-  const home = homeFlag === true ? bail("E_BAD_ARGS", "--home needs an absolute instance home") : homeFlag;
+  const homeFlag = flag("home"), soulFlag = flag("soul"), rootFlag = flag("agents-root");
+  if (homeFlag === true) return bail("E_BAD_ARGS", "--home needs an absolute instance home");
+  if (soulFlag === true) return bail("E_BAD_ARGS", "--soul needs a soul name");
+  if (rootFlag === true) return bail("E_BAD_ARGS", "--agents-root needs an absolute agents directory");
+  const remoteOptions = remoteOptionsFromEnv();
+  if (homeFlag) {
+    if (!isAbsolute(homeFlag)) return bail("E_BAD_ARGS", "--home needs an absolute instance home");
+    let meta = null;
+    try { meta = JSON.parse(readFileSync(join(homeFlag, "instance.json"), "utf8")); } catch (e) { return bail("E_SESSION_UNKNOWN", `${homeFlag} is not an OATS instance home (${e.code === "ENOENT" ? "no instance.json" : e.message})`); }
+    if (isCapturedHome(meta)) { const e = capturedHomeRefusal(homeFlag, "nothing was read"); return bail(e.code, e.message, e.details); }
+    if (!meta || typeof meta.modules !== "object" || meta.modules === null) return bail("E_UNSUPPORTED_MODE", `${homeFlag} is not a workspace-model home (it records no modules): it was spawned by an earlier kernel — re-spawn it from the deployment`);
+    if (soulFlag && soulFlag !== meta.agent) return bail("E_HOME_MISMATCH", `--soul ${soulFlag} is not the soul of ${homeFlag} (${meta.agent})`);
+    const deployment = dirname(dirname(dirname(dirname(realOrResolved(homeFlag)))));
+    // A v2 home lives at <deployment>/agents/<soul>/instances/<name>: its deployment is
+    // derived, so it must hold oats-local.yaml EXACTLY there (never found by walking up).
+    if (!existsSync(join(deployment, "oats-local.yaml"))) return bail("E_HOME_MISMATCH", `${homeFlag} is not at <deployment>/agents/<soul>/instances/<name>: ${deployment} has no oats-local.yaml`, { home: homeFlag, expected: join(deployment, "oats-local.yaml") });
+    if (flag("dir") !== undefined) { let given = null; try { given = dirname(loadLocal(dirFlag()).path); } catch { given = dirFlag(); } if (realOrResolved(given) !== realOrResolved(deployment)) return bail("E_HOME_MISMATCH", `--dir ${dirFlag()} is not the deployment of ${homeFlag} (${deployment}); omit --dir for a home`); }
+    if (rootFlag && realOrResolved(rootFlag) !== realOrResolved(join(deployment, "agents"))) return bail("E_HOME_MISMATCH", `--agents-root ${rootFlag} is not the agents root of ${homeFlag}`);
+    return homeTarget(homeFlag, meta, { remoteOptions, discover: command === "readiness", live: liveTeams });
+  }
+  try { if (!isWorkspaceContext(dirFlag())) return bail("E_LOCAL_MISSING", `${command} reads a workspace deployment, and none is in reach of ${dirFlag()} (no oats-local.yaml walking up; \`oats onboard\` creates one) — or pass --home <abs> of a workspace instance`); }
+  catch (e) { return bail(e?.code || "E_WORKSPACE_SCHEMA", e?.message || String(e), e?.details); }
+  if (!soulFlag) return bail("E_BAD_ARGS", `${command} on a workspace deployment needs --soul <name> or --home <abs>${command === "inspect" ? " (the deployment's souls and capabilities: oats souls / oats capabilities)" : ""}`);
+  const deployment = dirname(loadLocal(dirFlag()).path);
+  if (rootFlag && realOrResolved(rootFlag) !== realOrResolved(join(deployment, "agents"))) return bail("E_SOUL_UNKNOWN", `soul "${soulFlag}" is not at agents root ${rootFlag} (this deployment's is ${join(deployment, "agents")})`);
+  try { return await soulTarget(dirFlag(), String(soulFlag), { remoteOptions }); }
+  catch (e) { if (typeof e?.code === "string" && e.code.startsWith("E_")) return bail(e.code, e.message, e.details); throw e; }
+}
+function printWorkspaceInspect(doc) {
+  const s = doc.subject;
+  console.log(`oats inspect — ${s.kind === "instance" ? `instance ${s.instance} (soul ${s.soul}) ${shortPath(s.home)}` : `soul ${s.soul} from ${s.repoKey}`}`);
+  if (doc.identity) console.log(`  identity: ${servedIdentityLine(doc.identity)}`);
+  for (const l of LAYERS) console.log(`  ${l} capability: ${doc.layers[l].id || "none"}`);
+  for (const c of doc.capabilities) console.log(`  ${c.id}@${c.version || "?"} ${c.from?.kind === "package" ? `package ${c.from.package}` : c.from?.kind === "member" ? `member ${c.from.repoKey}` : ""}${c.operations.length ? `  ops: ${c.operations.map((o) => `${o.name}${o.available ? "" : "(unavailable)"}`).join(", ")}` : ""}`);
+  for (const p of doc.problems) console.log(`  ! ${p.code}: ${p.message}`);
+}
+
+/** `{ teams, teamsSource }` for a session start of a workspace home: its eligible teams read
+ *  live (two repository reads), which the launch hook re-checks joined memberships against
+ *  (teams contract decision 6) — or the spawn record, marked `recorded`, when the read cannot
+ *  answer. Anything that is not a readable workspace home gets nothing here — the start
+ *  itself refuses it. */
+async function homeLiveTeams(home) {
   let meta;
-  if (home) {
-    if (!isAbsolute(home)) bail("E_BAD_ARGS", "--home needs an absolute instance home");
-    const metaFile = join(home, "instance.json");
-    if (!existsSync(metaFile)) bail("E_SESSION_UNKNOWN", `${home} is not an OATS instance home (no instance.json)`);
-    try { meta = JSON.parse(readFileSync(metaFile, "utf8")); } catch (e) { bail("E_SESSION_UNKNOWN", `${metaFile}: ${e.message}`); }
-  }
-  const real = realOrResolved;
-  let ctx;
-  if (meta) {
-    // The home is the identity and its recorded repository is ALWAYS its
-    // context (that is what composed it); an explicit --dir is accepted only
-    // as an alias naming that repository or the workspace of the home's
-    // agents root, and never replaces the context.
-    const contexts = homeContexts(home, meta);
-    if (flag("dir") !== undefined) { const given = dirFlag(); if (!contexts.some((c) => real(c) === real(given))) bail("E_HOME_MISMATCH", `--dir ${given} is not the context of ${home} (${contexts.join(" or ")}); omit --dir for a home`); }
-    ctx = contexts[0];
-  } else ctx = dirFlag();
-  const soulFlag = flag("soul");
-  if (soulFlag === true) bail("E_BAD_ARGS", "--soul needs a soul name");
-  if (meta && soulFlag && soulFlag !== meta.agent) bail("E_HOME_MISMATCH", `--soul ${soulFlag} is not the soul of ${home} (${meta.agent})`);
-  const soulName = soulFlag || meta?.agent || undefined;
-  let agentsRootFlag = flag("agents-root");
-  if (agentsRootFlag === true) bail("E_BAD_ARGS", "--agents-root needs an absolute agents directory");
-  if (meta) {
-    // The soul is the home's own, under the home's own root; same-named souls
-    // in other member repositories are ordinary and never ambiguous here.
-    const homeRoot = agentsRootOfHome(real(home));
-    if (agentsRootFlag && real(agentsRootFlag) !== real(homeRoot)) bail("E_HOME_MISMATCH", `--agents-root ${agentsRootFlag} is not the agents root of ${home} (${homeRoot})`);
-    agentsRootFlag = homeRoot;
-  }
-  let r;
-  try { r = resolveOatsConfig(ctx, soulName); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-  let chain = configChain(ctx);
-  const enumerated = scopeSouls(ctx, r, { extraRoots: meta ? [agentsRootOfHome(realOrResolved(home))] : [] });
-  const roots = enumerated.roots;
-  let souls = enumerated.souls;
-  const packagedDiagnostics = enumerated.diagnostics;
-  let selectedSoul = null;
-  const requestedContext = ctx;
-  if (soulName) {
-    try { selectedSoul = selectSoul(souls, soulName, agentsRootFlag, ctx); } catch (e) { bail(e.code || "E_SOUL_UNKNOWN", e.message); }
-    selectedSoul.instructions = readTextCapped(selectedSoul.instructionsFile);
-    souls = [selectedSoul];
-    // A soul's effective bindings are its own member's: a team root or
-    // another member's --dir must not be applied to it. (A home keeps its
-    // recorded repository as its context; that is what composed it.)
-    if (!meta) {
-      const member = memberContextOf(selectedSoul, ctx, flag("dir") !== undefined, bail);
-      if (member !== realOrResolved(ctx)) {
-        ctx = member;
-        try { r = resolveOatsConfig(ctx, soulName); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-        chain = configChain(ctx);
-      }
-    }
-  }
-
-  // Capabilities: installed state and health from the package engine (exactly
-  // what `oats list` reports), owned/path manifests beside them, and the
-  // ACTIVATION for the selected soul (or global) from the resolver.
-  const mans = capabilityManifests(manifestSource(meta, home, ctx));
-  let lockError = null;
-  const byId = new Map();
-  try {
-    const pkgs = listInstalledPackages(ctx), locks = readPackageLocks(ctx);
-    for (const p of pkgs) {
-      const rows = levelRows(locks, p.level);
-      for (const c of p.capabilities) {
-        const h = capabilityHealth(p.level, c, rows.capabilities[c.id], rows.packages[p.package]);
-        byId.set(c.id, {
-          id: c.id, package: p.package, version: c.version || null, layer: c.manifest?.layer || null, command: c.manifest?.command || null,
-          origin: "installed", level: p.level, source: p.source || null, commit: p.commit ?? rows.packages[p.package]?.commit ?? null, dir: h.dir,
-          health: { status: h.status, code: h.code, detail: h.detail, installed: !!c.installed, locked: true, trusted: c.trusted === true, executableSurface: hasExecutableSurface(c.manifest), integrity: c.integrity || null, installedIntegrity: h.integrity ?? null },
-        });
-      }
-    }
-  } catch (e) { lockError = { code: e.code || "invalid-lock", message: e.message }; }
-  for (const [id, m] of Object.entries(mans)) {
-    if (byId.has(id)) continue;
-    const trust = capabilityTrust(m, ctx);
-    const executable = hasExecutableSurface(m);
-    let integrity = trust.integrity || null;
-    if (!integrity) { try { integrity = capabilityArtifactIntegrity(m._dir); } catch { integrity = null; } }
-    byId.set(id, {
-      id, package: m._package || null, version: m.version || null, layer: m.layer || null, command: m.command || null,
-      origin: String(m._origin || "").split(":")[0] || "unknown", level: String(m._origin || "").split(":").slice(1).join(":") || null, source: null, dir: m._dir,
-      health: { status: executable && !trust.trusted ? "untrusted" : "ok", code: executable && !trust.trusted ? "untrusted-surface" : null, detail: executable && !trust.trusted ? (trust.reason || null) : null, executableSurface: executable, installed: true, locked: !!trust.lock, trusted: !!trust.trusted, integrity, installedIntegrity: integrity },
-    });
-  }
-  // What is EFFECTIVE for the answer: a home's captured bindings and settings
-  // (with the currently acquired manifests and current trust); a soul's or
-  // scope's current config otherwise. The current config is reported
-  // separately for a home so a GUI can show both without confusing them.
-  const snapshotCaps = meta ? (meta.capabilities || []) : null;
-  const layerIdOf = (rec) => { const m = typeof rec === "string" ? /^([a-z0-9][a-z0-9._-]*)(?:\s|$)/.exec(rec) : null; return m && m[1] !== "none" ? m[1] : null; };
-  const effectiveLayers = meta
-    ? Object.fromEntries(LAYERS.map((l) => { const id = layerIdOf(meta.layers?.[l]) || snapshotCaps.find((c) => mans[c.id]?.layer === l)?.id || null; const rec = typeof meta.layers?.[l] === "string" ? meta.layers[l] : null; return [l, { id, level: snapshotCaps.find((c) => c.id === id)?.level || null, provenance: rec, disabled: !id && !!rec && rec.startsWith("none") }]; }))
-    : Object.fromEntries(LAYERS.map((l) => [l, r.layers[l]
-      ? { id: r.layers[l].id, level: r.layers[l].level, provenance: r.provenance[l] || null, disabled: false }
-      : { id: null, level: r.layerDisabled?.[l]?.level || null, provenance: r.provenance[l] || null, disabled: !!r.layerDisabled?.[l] }]));
-  const effectiveActive = (id) => meta
-    ? (() => { const c = snapshotCaps.find((x) => x.id === id); return c ? { id, level: c.level || null, provenance: c.provenance || [], settings: c.settings || {} } : undefined; })()
-    : r.capabilities.find((c) => c.id === id);
-  const declaredAt = (id) => chain.flatMap((cfg) => configCapabilityEntries(cfg).filter((e) => e.id === id).map((e) => ({ level: cfg._level, slot: e.slot || null, targets: [
-    ...(e.spec.global !== undefined ? [`global`] : []),
-    ...Object.keys(e.spec["agent-types"] || {}).map((t) => `type:${t}`),
-    ...Object.keys(e.spec.souls || {}).map((sn) => `soul:${sn}`),
-  ] })));
-  const targetOf = (provenance) => [...provenance].map((p) => p.split(" @ ")[0]).sort((a, b) => (b.startsWith("soul:") ? 2 : b.startsWith("type:") ? 1 : 0) - (a.startsWith("soul:") ? 2 : a.startsWith("type:") ? 1 : 0))[0] || (meta ? "snapshot" : "global");
-  const capabilities = [...byId.values()].sort((a, b) => a.id.localeCompare(b.id)).map((entry) => {
-    const active = effectiveActive(entry.id);
-    const m = mans[entry.id];
-    const missingRequires = (() => { try { return capabilityMissingRequires(entry.id, ctx).map((x) => ({ command: x.command, why: x.why || null, install: x.install || null })); } catch { return []; } })();
-    const disabledLayer = entry.layer && (meta ? (effectiveLayers[entry.layer]?.disabled ? { level: null } : null) : r.layerDisabled?.[entry.layer]);
-    const declared = declaredAt(entry.id);
-    const activation = active
-      ? { enabled: true, source: meta ? "snapshot" : "config", target: targetOf(active.provenance || []), level: active.level, provenance: active.provenance || [], settings: active.settings || {}, declaredAt: declared }
-      : { enabled: false, source: meta ? "snapshot" : "config", target: declared.length ? "declared" : "none", level: declared[0]?.level || null, provenance: [], settings: {}, declaredAt: declared, ...(disabledLayer ? { reason: `layer ${entry.layer} is disabled${disabledLayer.level ? ` at ${disabledLayer.level}` : " for this home"}` } : {}) };
-    const operations = manifestOperations(m).map((op) => {
-      let reason = null;
-      if (!active) reason = disabledLayer ? `layer ${entry.layer} is disabled${disabledLayer.level ? ` at ${disabledLayer.level}` : " for this home"}` : `${entry.id} is not activated for ${meta ? `home ${basename(home)}` : soulName ? `soul ${soulName}` : "this scope"}`;
-      else if (!entry.health.trusted) reason = `${entry.id} executable surface is not trusted (approve it in oats sync)`;
-      else if (entry.health.status !== "ok") reason = entry.health.detail || entry.health.status;
-      else if (missingRequires.length) reason = `${entry.id} requires ${missingRequires.map((x) => `"${x.command}" on PATH${x.why ? ` (${x.why})` : ""}`).join(", ")}`;
-      else if (op.context === "home" && !home) reason = "needs a running home (--home)";
-      return { ...op, argv: [entry.command, op.command], available: !reason, reason };
-    });
-    return { ...entry, missingRequires, activation, operations };
-  });
-  const layers = effectiveLayers;
-  // For a home, the CURRENT config beside the captured bindings, so a GUI can
-  // show what future instances would get without mistaking it for the home's.
-  const currentConfig = meta ? {
-    layers: Object.fromEntries(LAYERS.map((l) => [l, r.layers[l] ? { id: r.layers[l].id, level: r.layers[l].level, provenance: r.provenance[l] || null, disabled: false } : { id: null, level: r.layerDisabled?.[l]?.level || null, provenance: r.provenance[l] || null, disabled: !!r.layerDisabled?.[l] }])),
-    activations: r.capabilities.map((c) => ({ id: c.id, target: targetOf(c.provenance), level: c.level, settings: c.settings || {} })),
-  } : null;
-  const knowledgeCap = layers.knowledge.id ? capabilities.find((c) => c.id === layers.knowledge.id) : null;
-  const knowledge = knowledgeCap ? { provider: knowledgeCap.id, version: knowledgeCap.version, operations: knowledgeCap.operations.map((o) => ({ name: o.name, kind: o.kind, available: o.available, reason: o.reason })) } : { provider: null, version: null, operations: [] };
-
-  let snapshot = null;
-  if (meta) {
-    const runtimeById = new Map((meta.capabilityRuntime || []).map((c) => [c.id, c]));
-    const drift = [];
-    for (const c of meta.capabilities || []) {
-      const now = r.capabilities.find((x) => x.id === c.id);
-      if (!now) { drift.push({ id: c.id, field: "activation", snapshot: true, config: false }); continue; }
-      if (JSON.stringify(c.settings || {}) !== JSON.stringify(now.settings || {})) drift.push({ id: c.id, field: "settings", snapshot: c.settings || {}, config: now.settings || {} });
-      const then = runtimeById.get(c.id)?.trust?.integrity, cur = byId.get(c.id)?.health?.integrity;
-      if (then && cur && then !== cur) drift.push({ id: c.id, field: "integrity", snapshot: then, config: cur });
-    }
-    for (const now of r.capabilities) if (!(meta.capabilities || []).some((c) => c.id === now.id)) drift.push({ id: now.id, field: "activation", snapshot: false, config: true });
-    snapshot = {
-      home, instance: meta.instance, agent: meta.agent, runtime: meta.runtime || null, model: meta.model ?? null, yolo: meta.yolo ?? null, launched: !!meta.launched, createdAt: meta.createdAt || null,
-      layers: meta.layers || {}, capabilities: (meta.capabilities || []).map((c) => ({ id: c.id, level: c.level, settings: c.settings || {}, trusted: runtimeById.get(c.id)?.trust?.trusted ?? null })),
-      instructions: { ...readTextCapped(join(home, "AGENTS.md")), sources: meta.instructions || [] }, drift,
-    };
-  }
-  // K4: the deployment's portable source context and each soul's declared
-  // requirements joined against the capability inventory in this same payload.
-  // Readiness is about the soul's declared sources, kept apart from
-  // launchability (spawn) and adoption (prepare); unobservable = null.
-  const capabilityById = new Map(capabilities.map((c) => [c.id, c]));
-  for (const s of souls) {
-    const required = s.declarations?.requires?.capabilities;
-    const requirements = required && typeof required === "object" ? Object.entries(required).map(([id, spec]) => {
-      const cap = capabilityById.get(id) || null;
-      return { capability: id, source: spec && typeof spec === "object" ? spec.source ?? null : null,
-        installed: cap ? cap.health?.installed ?? null : false, approved: cap ? cap.health?.trusted ?? null : null,
-        active: cap ? !!cap.activation?.enabled : null, version: cap?.version ?? null };
-    }) : null;
-    s.readiness = { source: s.provenance ? "recorded" : "unrecorded", requirements,
-      status: requirements === null ? "undeclared" : requirements.every((q) => q.installed === true) ? "sources-installed" : requirements.some((q) => q.installed === false) ? "sources-missing" : "unknown" };
-  }
-  const sourceKey = (p) => JSON.stringify([p.source, p.revision, p.path]);
-  const sourceItems = [...new Map(souls.filter((s) => s.provenance?.source).map((s) => [sourceKey(s.provenance), { ...s.provenance, souls: [] }])).values()];
-  for (const s of souls) if (s.provenance?.source) sourceItems.find((i) => sourceKey(i) === sourceKey(s.provenance)).souls.push(s.name);
-  const sources = { soulsApi: 1, kind: sourceItems.length ? "recorded-provenance" : "none-recorded", items: sourceItems,
-    note: sourceItems.length ? null : "no soul in this scope records a portable source address" };
-  const result = {
-    operationsApi: 1, kernel: OATS_VERSION,
-    scope: { context: ctx, requestedContext: requestedContext === ctx ? null : requestedContext, workspace: roots.length ? workspaceOf(roots[0]) : ctx, team: r.team || null, chain: chain.map((c) => ({ file: c._file, level: c._level, levelKind: levelOf(c._level) })), agentsRoots: roots },
-    selected: { soul: selectedSoul?.name || null, agentsRoot: selectedSoul?.agentsRoot || null, home: home || null, source: meta ? "snapshot" : "config",
-      // Decision 27 (K2): the principal this home acts as, from its messaging provider's hook meta.
-      ...(meta ? { identity: servedIdentityOf(meta) } : {}) },
-    souls, sources, layers, capabilities, knowledge, snapshot, currentConfig,
-    problems: [...(lockError ? [lockError] : []), ...packagedDiagnostics.map((d) => ({ code: d.code, message: d.message, capability: d.capability })),
-      ...(meta ? snapshotCaps.filter((c) => !mans[c.id]).map((c) => ({ code: "captured-capability-missing", message: `${c.id} was active when this home was composed but no manifest for it is acquired now`, capability: c.id })) : [])],
-  };
-  result._print = { ctx, selectedSoul, home };
-  return result;
-}
-function printInspect(result) {
-  const { ctx, selectedSoul, home } = result._print; delete result._print;
-  const { souls, layers, capabilities } = result;
-  console.log(`oats inspect — ${shortPath(ctx)}${selectedSoul ? ` soul ${selectedSoul.name}` : ""}${home ? ` home ${shortPath(home)}` : ""}`);
-  if (result.selected?.identity) console.log(`  identity: ${servedIdentityLine(result.selected.identity)}`);
-  for (const s of souls) console.log(`  soul ${s.name} [${s.kind}${s.capability ? ` ${s.capability}` : ""}] runtime ${s.runtime}${s.model ? ` model ${s.model}` : ""} work ${s.work}${s.editable.fields.length ? "" : " (read-only)"}`);
-  for (const l of LAYERS) console.log(`  layer ${l}: ${layers[l].id || (layers[l].disabled ? "disabled" : "none")}${layers[l].provenance ? `  (${layers[l].provenance})` : ""}`);
-  for (const c of capabilities) console.log(`  ${c.id}@${c.version || "?"} ${c.health.status}${c.activation.enabled ? ` active:${c.activation.target}` : " inactive"}${c.operations.length ? `  ops: ${c.operations.map((o) => `${o.name}${o.available ? "" : "(unavailable)"}`).join(", ")}` : ""}`);
-  for (const p of result.problems) console.log(`  ! ${p.code}: ${p.message}`);
+  try { meta = JSON.parse(readFileSync(join(home, "instance.json"), "utf8")); } catch { return {}; }
+  if (!isWorkspaceHome(meta)) return {};
+  const { liveTeams } = await import("../lib/instance-resolution.mjs");
+  const { teams, source } = await liveTeams(home, meta, { remoteOptions: remoteOptionsFromEnv() });
+  return Array.isArray(teams) ? { teams, teamsSource: source } : {};
 }
 
 // ---------- operation run: generic invoke through the capability engine ----------
@@ -969,11 +385,11 @@ const OPERATION_ADDRESS_RE = /^(knowledge|messaging|tasks):([a-z][a-z0-9-]*)$/;
 const reportsRetainedEffectsText = (message) => /INCOMPLETE|quarantin|retain|could not (?:be )?(?:verif|confirm)/i.test(String(message || ""));
 // Comfortably below the scheduler's 5-minute command bound and any GUI
 // proxy, so the receipt always reaches the caller before a wrapper gives up.
-const OPERATION_TIMEOUT_MS = CAPTURED_OPERATION_TIMEOUT_MS;
-function finishOperation({ r, bail, address, provider, op, argFlags, cwd, home, meta, cleanupError, intent, settlement }) {
+const OPERATION_TIMEOUT_MS = 4 * 60 * 1000;
+function finishOperation({ r, bail, address, provider, op, argFlags, cwd, home, meta, cleanupError, intent, settlement, api }) {
   const stderr = String(r.stderr || "").trim();
   const timedOut = r.error?.code === "ETIMEDOUT" || (r.status === null && ["SIGTERM", "SIGKILL"].includes(r.signal) && (!settlement || !r.error));
-  const base = { operation: address, capability: provider.capability, version: provider.version || null, argv: [provider.command, op.command, ...argFlags], cwd, target: home ? { home, instance: meta.instance } : null };
+  const base = { ...(api ? { operationsApi: api } : {}), operation: address, capability: provider.capability, version: provider.version || null, argv: [provider.command, op.command, ...argFlags], cwd, target: home ? { home, instance: meta.instance } : null };
   // Unconfirmed outcomes (a timeout, no valid receipt, a receipt contradicted
   // by the exit status) carry what WAS observed in error.details, so a
   // scheduler can keep the slot as unknown and reconcile by any name the
@@ -1018,58 +434,8 @@ function finishOperation({ r, bail, address, provider, op, argFlags, cwd, home,
   else console.log(JSON.stringify(result, null, 2));
   if (stderr) console.error(stderr);
 }
-function operationCmd() {
-  const bail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
-  dropAmbientRoot();
-  if (args[1] !== "run") bail("E_USAGE", "usage: oats operation run <layer>:<name> (--home <abs> | --soul <name> [--dir <scope>] [--agents-root <abs>]) [--arg k=v ...] [--json]");
-  const address = args[2];
-  const m0 = typeof address === "string" ? OPERATION_ADDRESS_RE.exec(address) : null;
-  if (!m0) bail("E_BAD_ARGS", `operation address must be <layer>:<name> with layer one of ${LAYERS.join(", ")} (got ${JSON.stringify(address)})`);
-  const [, layer, opName] = m0;
-  const homeFlag = flag("home");
-  if (homeFlag === true) bail("E_BAD_ARGS", "--home needs an absolute instance home");
-  const home = homeFlag ? resolve(homeFlag) : undefined;
-  let meta;
-  if (home) {
-    if (!isAbsolute(homeFlag)) bail("E_BAD_ARGS", "--home needs an absolute instance home");
-    const metaFile = join(home, "instance.json");
-    if (!existsSync(metaFile)) bail("E_SESSION_UNKNOWN", `${home} is not an OATS instance home (no instance.json)`);
-    try { meta = JSON.parse(readFileSync(metaFile, "utf8")); } catch (e) { bail("E_SESSION_UNKNOWN", `${metaFile}: ${e.message}`); }
-  }
-  // The home is the identity: an explicit --dir must be one of its own
-  // contexts, never a different scope's config applied to it.
-  let ctx;
-  if (meta) {
-    // The recorded repository is always a home's context; --dir is only an
-    // alias to validate (the repository or the workspace of the home's root).
-    const contexts = homeContexts(home, meta);
-    if (flag("dir") !== undefined) { const given = dirFlag(); if (!contexts.some((c) => realOrResolved(c) === realOrResolved(given))) bail("E_HOME_MISMATCH", `--dir ${given} is not the context of ${home} (${contexts.join(" or ")}); omit --dir for a home`); }
-    ctx = contexts[0];
-  } else ctx = dirFlag();
-  const soulFlag = flag("soul");
-  if (soulFlag === true) bail("E_BAD_ARGS", "--soul needs a soul name");
-  if (meta && soulFlag && soulFlag !== meta.agent) bail("E_HOME_MISMATCH", `--soul ${soulFlag} is not the soul of ${home} (${meta.agent})`);
-  const soulName = soulFlag || meta?.agent || undefined;
-  let agentsRootFlag = flag("agents-root");
-  if (agentsRootFlag === true) bail("E_BAD_ARGS", "--agents-root needs an absolute agents directory");
-  if (meta) {
-    const homeRoot = agentsRootOfHome(realOrResolved(home));
-    if (agentsRootFlag && realOrResolved(agentsRootFlag) !== realOrResolved(homeRoot)) bail("E_HOME_MISMATCH", `--agents-root ${agentsRootFlag} is not the agents root of ${home} (${homeRoot})`);
-    agentsRootFlag = homeRoot;
-  }
-  // The same soul selection as inspect: name plus agents root, refused when
-  // ambiguous, never silently the first match.
-  let selectedSoul;
-  if (soulName) {
-    let rSel;
-    try { rSel = resolveOatsConfig(ctx, meta ? undefined : soulName); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-    try { selectedSoul = selectSoul(scopeSouls(ctx, rSel, { extraRoots: meta ? [agentsRootOfHome(realOrResolved(home))] : [] }).souls, soulName, agentsRootFlag, ctx); } catch (e) { bail(e.code || "E_SOUL_UNKNOWN", e.message); }
-    // The provider and its settings are the selected soul's own member's,
-    // never a team root's or another member's (a home keeps its recorded
-    // repository as its context).
-    if (!meta) ctx = memberContextOf(selectedSoul, ctx, flag("dir") !== undefined, bail);
-  }
-  // --arg k=v pairs, matched against the operation's declared args below.
+/** --arg k=v pairs of `oats operation run`. */
+function operationArgs(bail) {
   const given = Object.create(null);
   for (let i = 3; i < args.length; i++) {
     if (args[i] !== "--arg") continue;
@@ -1079,210 +445,92 @@ function operationCmd() {
     given[kv.slice(0, eq)] = kv.slice(eq + 1);
     i++;
   }
-  // Provider resolution: the snapshot's active capabilities for a home, the
-  // config for a soul/scope.
-  const mans = capabilityManifests(manifestSource(meta, home, ctx));
-  let provider, settings, team, disabled = null;
-  if (meta) {
-    const ids = (meta.capabilities || []).map((c) => c.id);
-    const id = ids.find((cid) => mans[cid]?.layer === layer);
-    provider = id ? mans[id] : undefined;
-    settings = (meta.capabilities || []).find((c) => c.id === id)?.settings || {};
-    team = meta.team || (() => { try { return resolveOatsConfig(ctx).team; } catch { return undefined; } })();
-    if (!provider) { const rec = meta.layers?.[layer]; disabled = typeof rec === "string" && rec.startsWith("none") ? rec : null; }
-  } else {
-    let r;
-    try { r = resolveOatsConfig(ctx, soulName); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-    provider = r.layers[layer] ? mans[r.layers[layer].id] : undefined;
-    settings = r.layers[layer]?.settings || {};
-    team = r.team;
-    if (!provider && r.layerDisabled?.[layer]) disabled = `none @ ${r.layerDisabled[layer].level}`;
-  }
-  if (!provider) bail("E_OPERATION_UNAVAILABLE", disabled ? `layer ${layer} is explicitly disabled (${disabled}); no provider can run ${address}` : `no ${layer} provider is active for ${meta ? home : soulName ? `soul ${soulName} in ${ctx}` : ctx}`);
+  return given;
+}
+/** `oats operation run` on the workspace model (operationsApi 2): the provider is
+ *  the module filling <layer> — the home's own copy, or the soul's resolved module
+ *  fetched into the deployment's module store — with its merged payload as
+ *  OATS_SETTINGS and the team facts hooks get. */
+async function workspaceOperation(t, { bail, address, layer, opName }) {
+  if (t.resolutionError) return bail(t.resolutionError.code, t.resolutionError.message, t.resolutionError.details ?? undefined);
+  const name = t.slots[layer];
+  const mod = name ? t.modules.find((x) => x.name === name) : null;
+  if (!mod?.manifest) return bail("E_OPERATION_UNAVAILABLE", `no ${layer} provider is resolved for ${t.home ? t.home : `soul ${t.soul.name}`}`);
+  const provider = { ...mod.manifest, capability: mod.name };
   const op = manifestOperations(provider).find((o) => o.name === opName);
-  if (!op) bail("E_OPERATION_UNKNOWN", `${provider.capability} declares no operation ${JSON.stringify(opName)} (declared: ${manifestOperations(provider).map((o) => o.name).join(", ") || "none"})`);
-  const trust = capabilityTrust(provider, ctx);
-  if (!trust.trusted) bail("E_CAPABILITY_BLOCKED", `${provider.capability} executable surface is blocked: ${trust.reason || "not trusted"} (approve it in oats sync)`);
-  const missingReq = capabilityMissingRequires(provider.capability, ctx);
-  if (missingReq.length) bail("E_CAPABILITY_REQUIRES", `${provider.capability} requires ${missingReq.map((m) => `"${m.command}" on PATH${m.why ? ` (${m.why})` : ""}${m.install ? ` [install: ${m.install}]` : ""}`).join(", ")}; ${address} was not run`);
-  if (op.context === "home" && !meta) bail("E_OPERATION_UNAVAILABLE", `${address} runs in an instance home; pass --home <abs>`);
+  if (!op) return bail("E_OPERATION_UNKNOWN", `${mod.name} declares no operation ${JSON.stringify(opName)} (declared: ${manifestOperations(provider).map((o) => o.name).join(", ") || "none"})`);
+  const missingReq = manifestMissingRequires(provider);
+  if (missingReq.length) return bail("E_CAPABILITY_REQUIRES", `${mod.name} requires ${missingReq.map((m) => `"${m.command}" on PATH${m.why ? ` (${m.why})` : ""}${m.install ? ` [install: ${m.install}]` : ""}`).join(", ")}; ${address} was not run`);
+  if (op.context === "home" && !t.home) return bail("E_OPERATION_UNAVAILABLE", `${address} runs in an instance home; pass --home <abs>`);
+  const given = operationArgs(bail);
   const declared = new Map(op.args.map((a) => [a.name, a]));
-  for (const name of Object.keys(given)) if (!declared.has(name)) bail("E_BAD_ARGS", `${address} takes no arg ${JSON.stringify(name)} (declared: ${[...declared.keys()].join(", ") || "none"})`);
-  for (const a of op.args) if (a.required && given[a.name] === undefined) bail("E_BAD_ARGS", `${address} needs --arg ${a.name}=<value>: ${a.description || "required"}`);
+  for (const n of Object.keys(given)) if (!declared.has(n)) return bail("E_BAD_ARGS", `${address} takes no arg ${JSON.stringify(n)} (declared: ${[...declared.keys()].join(", ") || "none"})`);
+  for (const a of op.args) if (a.required && given[a.name] === undefined) return bail("E_BAD_ARGS", `${address} needs --arg ${a.name}=<value>: ${a.description || "required"}`);
   const argFlags = op.args.flatMap((a) => (given[a.name] === undefined ? [] : [a.flag, given[a.name]]));
-  const spec = provider.commands[op.command];
-  if (typeof spec !== "string" || !spec.trim()) bail("E_CAPABILITY_BROKEN", `${provider.capability}: command ${op.command} is not a non-empty string`);
+  const spec = provider.commands?.[op.command];
+  if (typeof spec !== "string" || !spec.trim()) return bail("E_CAPABILITY_BROKEN", `${mod.name}: command ${op.command} is not a non-empty string`);
+  let catalog = null; try { catalog = officialPackageCatalog(); } catch { catalog = null; }
+  const { layerProvider } = await import("../lib/instance-inspect.mjs");
+  let lp;
+  try { lp = await layerProvider(t, layer, { catalog, remoteOptions: remoteOptionsFromEnv() }); } catch (e) { return bail(e.code || "E_CAPABILITY_BROKEN", e.message, e.details); }
   const [script, ...rest] = spec.trim().split(/\s+/);
-  let abs;
-  try { abs = capabilityExecutablePath(provider, script); } catch (e) { bail("E_CAPABILITY_BROKEN", e.message); }
-  if (!abs) bail("E_CAPABILITY_BROKEN", `${provider.capability} ${op.command}: script not found (${join(provider._dir, script)})`);
-  const cwd = op.context === "home" ? home : ctx;
-  // The provider sees exactly the selected target: identity and context
-  // variables are SET for it (a home, or a soul in a scope) and every
-  // ambient one from the invoking process is removed, so a coordinator
-  // running this for another home never steers the provider to its own.
-  const env = { ...process.env };
-  for (const k of ["OATS_EVENT", "OATS_INSTANCE", "OATS_INSTANCE_HOME", "OATS_HOME", "OATS_AGENT", "OATS_SOUL", "OATS_CONTEXT", "OATS_ROOT", "OATS_WORKSPACE", "OATS_LEVEL", "OATS_META", "OATS_KIND", "PI_AGENT_INSTANCE", "PI_AGENT_HOME", "PI_AGENTS_ROOT"]) delete env[k];
-  const targetRoot = meta ? agentsRootOfHome(realOrResolved(home)) : selectedSoul?.agentsRoot;
-  const soulDir = meta ? join(dirname(dirname(realOrResolved(home))), "soul") : selectedSoul ? dirname(selectedSoul.soulFile) : undefined;
-  Object.assign(env, {
-    OATS_CAPABILITY: provider.capability, OATS_SETTINGS: JSON.stringify(settings || {}), OATS_CLI_BIN: CLI_BIN, OATS_OPERATION: address,
-    OATS_CONTEXT: ctx, OATS_WORKSPACE: targetRoot ? workspaceOf(targetRoot) : workspaceOf(findRoot(ctx) || ctx),
-    OATS_TEAM_NAME: team?.name || "", OATS_TEAM_ID: team?.id || "", OATS_TEAM_SCOPE: team?.scope || "",
-    ...(targetRoot ? { OATS_ROOT: targetRoot, PI_AGENTS_ROOT: targetRoot } : {}),
-    ...(soulName ? { OATS_AGENT: soulName } : {}), ...(soulDir ? { OATS_SOUL: soulDir } : {}),
-  });
-  if (op.context === "home") Object.assign(env, { OATS_INSTANCE: meta.instance, OATS_INSTANCE_HOME: home, OATS_HOME: home, PI_AGENT_INSTANCE: meta.instance, PI_AGENT_HOME: home });
+  const abs = lp?.executable(script);
+  if (!abs) return bail("E_CAPABILITY_BROKEN", `${mod.name} ${op.command}: script not found (${script})`);
+  const settings = lp.settings;
+  const cwd = op.context === "home" ? t.home : t.deployment;
+  const env = { ...lp.env(mod.name, settings), OATS_OPERATION: address, OATS_CONTEXT: t.deployment, OATS_ROOT: t.agentsRoot, PI_AGENTS_ROOT: t.agentsRoot };
+  if (op.context === "home") Object.assign(env, { OATS_INSTANCE: t.meta.instance, OATS_INSTANCE_HOME: t.home, OATS_HOME: t.home, PI_AGENT_INSTANCE: t.meta.instance, PI_AGENT_HOME: t.home });
+  else for (const k of ["OATS_INSTANCE", "OATS_INSTANCE_HOME", "OATS_HOME", "PI_AGENT_INSTANCE", "PI_AGENT_HOME"]) delete env[k];
   const r = spawnSync("node", [abs, ...rest, ...argFlags, "--json"], { cwd, env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 16 * 1024 * 1024, timeout: OPERATION_TIMEOUT_MS, killSignal: "SIGTERM" });
-  finishOperation({ r, bail, address, provider, op, argFlags, cwd, home, meta });
+  finishOperation({ r, bail, address, provider, op, argFlags, cwd, home: t.home, meta: t.meta, api: INSPECT_OPERATIONS_API });
 }
-
-// ---------- soul set: runtime defaults and instructions of an editable soul ----------
-/** Rewrites only the given soul.yaml fields, preserving every other line
- *  (unknown keys, comments, order), and replaces AGENTS.md when asked.
- *  Packaged souls are read-only (their source is the package). */
-async function soulCmd() {
-  const bail = (code, msg) => (JSON_MODE ? jsonFail(code, msg) : die(msg));
+async function operationCmd() {
+  const bail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
   dropAmbientRoot();
-  if (args[1] !== "set") bail("E_USAGE", "usage: oats soul set <name> [--dir <scope>] [--agents-root <abs>] [--runtime pi|claude|codex] [--model <m> | --no-model] [--yolo | --no-yolo] [--backend tmux|herdr] [--description <d> | --no-description] [--instructions-file <path> | --instructions-stdin] [--json]");
-  const name = args[2];
-  if (!name || name.startsWith("--")) bail("E_BAD_ARGS", "soul set needs a soul name");
-  const ctx = dirFlag();
-  const agentsRootFlag = flag("agents-root");
-  if (agentsRootFlag === true) bail("E_BAD_ARGS", "--agents-root needs an absolute agents directory");
-  let r;
-  try { r = resolveOatsConfig(ctx); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-  let soul;
-  try { soul = selectSoul(scopeSouls(ctx, r).souls, name, agentsRootFlag, ctx); } catch (e) { bail(e.code || "E_SOUL_UNKNOWN", e.message); }
-  if (!soul.editable.fields.length) bail("E_SOUL_READONLY", `${name} is a ${soul.kind} soul: ${soul.editable.reason}`);
-  // Field changes, validated before anything is written.
-  const changes = {};
-  const has = (f) => args.includes(`--${f}`);
-  const val = (f) => { const v = flag(f); if (v === true) bail("E_BAD_ARGS", `--${f} needs a value`); return v; };
-  if (has("runtime")) { const v = val("runtime"); if (!["pi", "claude", "codex"].includes(v)) bail("E_BAD_ARGS", "--runtime must be pi, claude or codex"); changes.runtime = v; }
-  if (has("model") && has("no-model")) bail("E_BAD_ARGS", "choose --model <m> or --no-model, not both");
-  if (has("model")) { const v = val("model"); if (!v.trim()) bail("E_BAD_ARGS", "--model needs a model id (use --no-model to clear)"); changes.model = assertSafeConfigValue(v, "--model"); }
-  if (has("no-model")) changes.model = null;
-  if (has("yolo") && has("no-yolo")) bail("E_BAD_ARGS", "choose --yolo or --no-yolo, not both");
-  if (has("yolo")) changes.yolo = true;
-  if (has("no-yolo")) changes.yolo = false;
-  if (has("backend")) { const v = val("backend"); if (!["tmux", "herdr"].includes(v)) bail("E_BAD_ARGS", "--backend must be tmux or herdr"); changes.backend = v; }
-  if (has("launch-config") && has("no-launch-config")) bail("E_BAD_ARGS", "choose --launch-config <name> or --no-launch-config, not both");
-  if (has("launch-config")) { const v = val("launch-config"); if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(v)) bail("E_BAD_ARGS", "--launch-config needs a configuration name (letters, digits, dot, underscore, dash)"); changes["launch-config"] = v; }
-  if (has("no-launch-config")) changes["launch-config"] = null;
-  if (has("description") && has("no-description")) bail("E_BAD_ARGS", "choose --description <d> or --no-description, not both");
-  if (has("description")) changes.description = assertSafeConfigValue(val("description"), "--description");
-  if (has("no-description")) changes.description = null;
-  let instructions;
-  if (has("instructions-file") && has("instructions-stdin")) bail("E_BAD_ARGS", "choose --instructions-file or --instructions-stdin, not both");
-  if (has("instructions-file")) {
-    const file = val("instructions-file");
-    let bytes;
-    try { bytes = readFileSync(file); } catch (e) { bail("E_BAD_ARGS", `--instructions-file ${file}: ${e.message}`); }
-    if (bytes.includes(0)) bail("E_BAD_ARGS", "--instructions-file must be text without NUL bytes");
-    if (bytes.length > INSPECT_TEXT_CAP) bail("E_BAD_ARGS", `--instructions-file is ${bytes.length} bytes; the bound is ${INSPECT_TEXT_CAP} (what inspect can answer whole)`);
-    instructions = bytes;
-  }
-  if (has("instructions-stdin")) {
-    // The routed form: bytes arrive on stdin (the ssh transport), bounded
-    // while reading, exactly like session receive.
-    if (process.stdin.isTTY) bail("E_BAD_ARGS", "--instructions-stdin reads the instructions from stdin");
-    let bytes;
-    try { bytes = await readStreamBounded(process.stdin, INSPECT_TEXT_CAP); } catch (e) { bail(e.code || "E_BAD_ARGS", e.message); }
-    if (bytes.includes(0)) bail("E_BAD_ARGS", "instructions must be text without NUL bytes");
-    // An empty completed stream is a deliberate replacement with nothing,
-    // exactly like an empty --instructions-file: the option itself states
-    // the intent, and a TTY was refused above.
-    instructions = bytes;
-  }
-  if (!Object.keys(changes).length && !instructions) bail("E_BAD_ARGS", "nothing to set: pass at least one of --runtime, --model/--no-model, --yolo/--no-yolo, --backend, --launch-config/--no-launch-config, --description/--no-description, --instructions-file");
-  for (const f of Object.keys(changes)) if (!soul.editable.fields.includes(f)) bail("E_BAD_ARGS", `${f} is not an editable field of ${name}`);
-  const before = { runtime: soul.runtime, model: soul.model, yolo: soul.yolo, backend: soul.backend, description: soul.description, launchConfig: soul.launchConfig };
-  // soul.yaml: replace or append `key: value` lines in place; a cleared
-  // field's line is removed; nothing else in the file moves.
-  let yamlText = "";
-  try { yamlText = readFileSync(soul.soulFile, "utf8"); } catch (e) { bail("E_SOUL_UNKNOWN", `${soul.soulFile}: ${e.message}`); }
-  const lines = yamlText.replace(/\n*$/, "").split("\n");
-  for (const [key, value] of Object.entries(changes)) {
-    const idx = lines.findIndex((l) => new RegExp(`^${key}:\\s`).test(l) || l === `${key}:`);
-    if (value === null) { if (idx >= 0) lines.splice(idx, 1); continue; }
-    const line = `${key}: ${value}`;
-    if (idx >= 0) lines[idx] = line; else lines.push(line);
-  }
-  const receipt = { soul: name, kind: soul.kind, agentsRoot: soul.agentsRoot, file: soul.soulFile, instructionsFile: soul.instructionsFile, changed: Object.keys(changes), before, instructions: null };
-  if (Object.keys(changes).length) writeFileAtomic(soul.soulFile, lines.join("\n") + "\n");
-  if (instructions) {
-    const prev = (() => { try { return createHash("sha256").update(readFileSync(soul.instructionsFile)).digest("hex"); } catch { return null; } })();
-    writeFileAtomic(soul.instructionsFile, instructions);
-    receipt.instructions = { before: prev, after: createHash("sha256").update(instructions).digest("hex"), bytes: instructions.length };
-  }
-  let after;
-  try { after = selectSoul(scopeSouls(ctx, r).souls, name, soul.agentsRoot, ctx); } catch { after = soul; }
-  receipt.after = { runtime: after.runtime, model: after.model, yolo: after.yolo, backend: after.backend, description: after.description };
-  if (JSON_MODE) { jsonOk(receipt); return; }
-  console.log(`Updated soul ${name} (${shortPath(soul.soulFile)})${instructions ? ` and its instructions (${shortPath(soul.instructionsFile)})` : ""}: ${Object.keys(changes).map((k) => `${k}=${changes[k] === null ? "(cleared)" : changes[k]}`).join(", ") || "instructions only"}`);
-  console.log("Future instances use these defaults; existing homes keep what they were composed with.");
+  if (args[1] !== "run") bail("E_USAGE", "usage: oats operation run <layer>:<name> (--home <abs> | --soul <name> [--dir <scope>] [--agents-root <abs>]) [--arg k=v ...] [--json]");
+  const address = args[2];
+  const m0 = typeof address === "string" ? OPERATION_ADDRESS_RE.exec(address) : null;
+  if (!m0) bail("E_BAD_ARGS", `operation address must be <layer>:<name> with layer one of ${LAYERS.join(", ")} (got ${JSON.stringify(address)})`);
+  const [, layer, opName] = m0;
+  // Only the messaging provider's operations act on the teams: others get the record, no remote read.
+  const target = await workspaceTarget(bail, { command: "operation run", liveTeams: layer === "messaging" });
+  return workspaceOperation(target, { bail, address, layer, opName });
 }
 
-function doctorJson(dir) {
-  const ctx = resolve(dir || process.cwd());
-  const soulName = flag("soul");
+
+/** Doctor answers on a workspace deployment only (lead decision c3-6): the
+ *  deployment found walking up from the given directory (positional or --dir),
+ *  else E_LOCAL_MISSING; an unreadable oats-local.yaml is its own error. */
+function doctorDeployment(dir) {
+  const bail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
+  const ctx = resolve(dir || dirFlag());
   const ws = doctorLockData(ctx);
-  // A v2 deployment (oats-local.yaml found walking up) has NO config chain, layers,
-  // acquired packages or installed tier: those keys are omitted, not emitted empty.
-  if (ws.local) { console.log(JSON.stringify(doctorWorkspaceJson(ctx, soulName, ws), null, 2)); return; }
-  const r = resolveForDoctor(ctx, soulName, { json: true });
-  const mans = capabilityManifests(ctx);
-  const composition = doctorComposition(ctx, soulName);
-  const chain = configChain(ctx);
-  const oasScopes = detectOasScopes(ctx);
-  console.log(JSON.stringify({
-    schemaVersion: 1,
-    context: ctx,
-    team: r.team || null,
-    chain: r.chain.map((c) => ({ file: c._file, level: c._level, levelKind: levelOf(c._level) })),
-    oasScopes,
-    oasRemedy: oasScopes.length ? OAS_SCOPE_REMEDY : null,
-    layers: Object.fromEntries(LAYERS.map((l) => [l, r.layers[l] ? {
-      integration: r.layers[l].id, level: r.layers[l].level, inject: r.layers[l].inject,
-      skills: [...(Array.isArray(r.layers[l].skills) ? r.layers[l].skills : (r.layers[l].skills ? [r.layers[l].skills] : []))],
-      hooks: Object.keys(r.layers[l].hooks || {}), missingRequires: r.layers[l].missingRequires,
-      provenance: r.provenance[l],
-    } : { provenance: r.provenance[l] || null }])),
-    kernelInjection: composition?.resolved.kernelInjection ?? r.kernelInjection,
-    information: operationalKnowledgeNote(composition, soulName) ? [operationalKnowledgeNote(composition, soulName)] : [],
-    injects: r.injects,
-    capabilities: r.capabilities.map((c) => ({ id: c.id, layer: c.layer, command: c.command, origin: c.origin, provenance: c.provenance, settings: c.settings, skills: c.skills, inject: c.inject, hooks: Object.keys(c.hooks || {}), trust: c.trust })),
-    acquired: Object.fromEntries(Object.entries(mans).map(([n, m]) => [n, { layer: m.layer, command: m.command, version: m.version, dir: m._dir, origin: m._origin, description: m.description }])),
-retiredLocks: (() => { try { return Object.entries(readCapabilityLocks(ctx)); } catch { return []; } })()
-      .filter(([id]) => retiredCapabilityReason(id))
-      .map(([id, lock]) => ({ id, file: lock._file, reason: retiredCapabilityReason(id) })),
-    retiredArtifacts: Object.entries(mans)
-      .filter(([id]) => retiredCapabilityReason(id))
-      .map(([id, m]) => ({ id, dir: m._dir, origin: m._origin, reason: retiredCapabilityReason(id) })),
-    // Workspace model v2 (offline view): the lock (v3) and the deployment
-    // declaration. Human and JSON doctor derive from ONE computation; a
-    // fail-closed lock read is diagnosed via lockError, never consumed as data.
-    workspace: ws.local ? { file: ws.local.path, ref: ws.local.workspace } : null,
-    workspaceError: ws.localError,
-    lockFile: ws.lockFile,
-    packages: ws.packages,
-    lockError: ws.lockError,
-    composedInstructions: composition?.text,
-    instructionBlocks: composition?.blocks,
-  }, null, 2));
+  if (ws.localError) bail(ws.localError.code, ws.localError.message, ws.localError.details);
+  if (!ws.local) bail("E_LOCAL_MISSING", `oats doctor reads a workspace deployment, and none is in reach of ${ctx} (no oats-local.yaml walking up; \`oats onboard\` creates one)`, { dir: ctx });
+  return { ctx, ws };
+}
+async function doctorJson(dir) {
+  const { ctx, ws } = doctorDeployment(dir);
+  console.log(JSON.stringify(await doctorWorkspaceJson(ctx, flag("soul"), ws), null, 2));
 }
 
 /** The v2 doctor payload: the deployment declaration + lock (offline) and, with
  *  --soul, the composed instructions. No v1 keys (chain/layers/acquired/injects…). */
-function doctorWorkspaceJson(ctx, soulName, ws) {
-  const composition = doctorComposition(ctx, soulName);
+/** The problems doctor and status share for a v2 deployment: what OATS 0.25 left
+ *  under local-agents/ (named, never read), and the captured homes under the agents root. */
+function legacyLayoutProblems(root) {
+  return [legacyLocalAgents(root), legacyCapturedHomes(root)].filter(Boolean);
+}
+async function doctorWorkspaceJson(ctx, soulName, ws) {
+  const composition = await doctorComposition(ctx, soulName, ws, (code, msg, details) => jsonFail(code, msg, details));
+  const problems = legacyLayoutProblems(join(dirname(ws.local.path), "agents"));
   return {
     schemaVersion: 1, workspaceApi: 2, context: ctx,
     workspace: { file: ws.local.path, ref: ws.local.workspace },
     workspaceError: ws.localError, lockFile: ws.lockFile, packages: ws.packages, lockError: ws.lockError,
     information: operationalKnowledgeNote(composition, soulName) ? [operationalKnowledgeNote(composition, soulName)] : [],
     composedInstructions: composition?.text, instructionBlocks: composition?.blocks,
+    ...(problems.length ? { problems } : {}),
   };
 }
 /** Kernel/bridge version skew (published in lockstep from one tag). */
@@ -1295,142 +543,26 @@ function doctorVersionSkew() {
 /** The "Workspace (v2, offline view)" + "Locked packages" sections, shared by both doctor shapes. */
 function printDoctorWorkspace(ws) {
   console.log("\nWorkspace (v2, offline view):");
-  if (ws.local) console.log(`  oats-local.yaml  ${shortPath(ws.local.path)}  → workspace ${ws.local.workspace}`);
-  else if (ws.localError) console.log(`  ERROR: ${ws.localError.message} [${ws.localError.code}]`);
-  else console.log("  (no oats-local.yaml found walking up — this scope realizes no v2 workspace; run `oats sync` from one that does)");
+  console.log(`  oats-local.yaml  ${shortPath(ws.local.path)}  → workspace ${ws.local.workspace}`);
   console.log("\nLocked packages (oats-lock.json v3):");
   if (ws.lockError) {
     console.log(`  ERROR: ${ws.lockError.message} [${ws.lockError.code}]`);
     if (ws.lockError.file) console.log(`         the lock is never auto-repaired; delete ${shortPath(ws.lockError.file)} and run \`oats sync\``);
   } else if (!ws.packages.length) console.log(ws.lockFile ? "  (none)" : "  (no lock yet — run `oats sync`)");
   for (const p of ws.packages) {
-    console.log(`  ${p.id} ${p.version}  ${p.source}  @ ${p.commit.slice(0, 12)}  ${p.approved ? `approved ${p.approved.at}` : "APPROVAL NEEDED (oats sync)"}`);
+    console.log(`  ${p.id} ${p.version}  ${p.source}  @ ${p.commit.slice(0, 12)}  ${p.integrity}`);
     if (p.capabilities.length) console.log(`             capabilities: ${p.capabilities.join(", ")}`);
   }
   console.log("  membership, discovery and drift need the remotes: `oats workspace status`, `oats sync`.");
 }
-function doctor(dir) {
-  const ctx = resolve(dir || process.cwd());
+async function doctor(dir) {
+  const { ctx, ws } = doctorDeployment(dir);
   const soulName = flag("soul");
-  const ws = doctorLockData(ctx);
   console.log(`oats doctor — resolved from ${shortPath(ctx)}\n`);
   doctorVersionSkew();
-  if (ws.local) {
-    // A v2 deployment: nothing is installed and there is no config chain — the v1
-    // sections (Config chain / Layers / Kernel injection / Acquired packages / lock
-    // warnings) would describe a tier this deployment does not have.
-    const composition = doctorComposition(ctx, soulName);
-    printDoctorWorkspace(ws);
-    if (soulName) {
-      const information = operationalKnowledgeNote(composition, soulName);
-      if (information) console.log(`\nINFO: ${information}`);
-      console.log(`\nFinal composed AGENTS.md for ${soulName}:\n\n${composition.text}`);
-    } else console.log("\nPass --soul <name> to inspect final composed AGENTS.md.");
-    return;
-  }
-  const chain = configChain(ctx);
-  const r = resolveForDoctor(ctx, soulName);
-  const composition = doctorComposition(ctx, soulName);
-
-  console.log("Config chain (closest first):");
-  if (chain.length === 0) console.log("  (none — no oats-config.yaml found walking up)");
-  for (const c of chain) {
-    console.log(`  ${shortPath(c._file)}  [${levelOf(c._level)}]`);
-  }
-
-  // An empty-looking chain over oas-* files is not an empty scope: it is a
-  // pre-rename OAS deployment this kernel cannot read (aweb-abfy.1).
-  const oasScopes = detectOasScopes(ctx);
-  if (oasScopes.length) {
-    console.log("");
-    for (const f of oasScopes) console.log(`UN-MIGRATED OAS SCOPE: ${shortPath(f.dir)}  (${f.files.join(", ")})`);
-    console.log(`  ${OAS_SCOPE_REMEDY}`);
-  }
-
-  if (r.team) console.log(`\nTeam: ${r.team.name}${r.team.id ? `  (id: ${r.team.id})` : ""}  [scope: ${shortPath(r.team.scope)}]`);
-
-  console.log("\nLayers:");
-  for (const layer of LAYERS) {
-    const l = r.layers[layer];
-    const prov = r.provenance[layer];
-    if (!prov) { console.log(`  ${layer.padEnd(10)} (unresolved — no declaration in chain)`); continue; }
-    if (!l) { console.log(`  ${layer.padEnd(10)} none  [${prov}]`); continue; }
-    console.log(`  ${layer.padEnd(10)} ${l.id}  [${prov}]`);
-    if (l.inject) console.log(`             inject: ${shortPath(l.inject)}`);
-    const skills = Array.isArray(l.skills) ? l.skills : (l.skills ? [l.skills] : []);
-    if (skills.length) console.log(`             skills: ${skills.map(shortPath).join(", ")}`);
-    const hooks = Object.keys(l.hooks || {});
-    if (hooks.length) console.log(`             hooks:  ${hooks.join(", ")}`);
-    for (const miss of l.missingRequires || []) {
-      console.log(`             MISSING REQUIREMENT: ${miss.command} — ${miss.why || ""}${miss.install ? ` (install: ${miss.install})` : ""}`);
-    }
-  }
-
-  console.log("\nKernel injection:");
-  const kernelInjection = composition?.resolved.kernelInjection ?? r.kernelInjection;
-  console.log(`  oats: ${kernelInjection?.inject ? shortPath(kernelInjection.inject) : "none"}  [${kernelInjection?.provenance || "default"}]`);
-
-  console.log("\nUnconditional injections (outermost→innermost):");
-  if (r.injects.length === 0) console.log("  (none)");
-  for (const inj of r.injects) console.log(`  ${inj.source}: ${shortPath(inj.file)}`);
-
-  for (const mode of WORK_MODES) {
-    const wm = resolveWorkMode(ctx, mode);
-    console.log(`\nWork mode ${mode}: inject ${wm.inject ? shortPath(wm.inject) : "none"}${wm.setup ? `, setup ${shortPath(wm.setup)}` : ""}`);
-  }
-
-  console.log("\nActive capabilities:");
-  if (!r.capabilities.length) console.log("  (none)");
-  for (const cap of r.capabilities) {
-    console.log(`  ${cap.id}${cap.layer ? `  layer: ${cap.layer}` : ""}  [${cap.provenance.join(" + ")}]`);
-    console.log(`             trust: ${cap.trust.trusted ? "approved" : `BLOCKED (${cap.trust.reason})`}`);
-    if (cap.inject) console.log(`             inject: ${shortPath(cap.inject)}`);
-    if (cap.skills.length) console.log(`             skills: ${cap.skills.map(shortPath).join(", ")}`);
-  }
-  console.log("\nAcquired capability packages:");
-  for (const [name, m] of Object.entries(capabilityManifests(ctx))) {
-    const missing = capabilityMissingRequires(name, ctx);
-    console.log(`  ${name.padEnd(16)} layer: ${(m.layer || "additive").padEnd(10)} origin: ${m._origin}${missing.length ? `  (missing: ${missing.map((x) => x.command).join(", ")})` : ""}`);
-    const retiredReason = retiredCapabilityReason(name);
-    if (retiredReason) {
-      const installed = String(m._origin).startsWith("installed:");
-      console.log(`             WARNING: artifact of a retired capability — ${retiredReason}${installed ? `; also delete ${shortPath(m._dir)}` : ` (origin ${m._origin}: remove its declaration; the source tree at ${shortPath(m._dir)} is yours to keep or drop)`}`);
-    }
-  }
-  // readCapabilityLocks fails closed on invalid legacy entries — doctor is the
-  // diagnosis surface, so catch the typed error and render it (never using the data).
-  let locks = {};
-  try { locks = readCapabilityLocks(ctx); }
-  catch (e) {
-    if (e.code !== "invalid-lock") throw e;
-    const prov = Array.isArray(e.provenance) ? e.provenance[0] : undefined;
-    console.log(`  ERROR: ${e.message} [invalid-lock]`);
-    if (prov?.file) console.log(`         fix or remove the entry in ${shortPath(prov.file)} — never auto-repaired; legacy trust/restore fail closed until it is valid`);
-  }
-  const mans = capabilityManifests(ctx);
-  for (const [id, lock] of Object.entries(locks)) {
-    const retiredReason = retiredCapabilityReason(id);
-    if (retiredReason) { console.log(`  WARNING: ${id} is locked in ${shortPath(lock._file)} but ${retiredReason}`); continue; }
-    if (!mans[id]) console.log(`  WARNING: ${id} is locked in ${shortPath(lock._file)} but not acquired — run \`oats sync\``);
-  }
-  for (const [id, m] of Object.entries(mans)) {
-    if (!String(m._origin).startsWith("installed:")) continue;
-    // SCOPE-EXACT on the v2 side. `m._capabilityLock` is the row from the
-    // artifact's OWN scope's lock (capabilityManifests annotates it there), and
-    // that is the only row that can lock this artifact: the merged chain would
-    // let an outer scope's lock — or a lock-only ancestor with no config at all
-    // — silence an unlocked inner copy that WINS discovery precedence and
-    // activates. The legacy arm stays chain-merged: v1 parity is unchanged.
-    if (m._capabilityLock || Object.hasOwn(locks, id)) continue;
-    console.log(`  WARNING: ${id} at ${shortPath(m._dir)} is in installed/ but has no lock entry — reacquire it or move it to owned/`);
-  }
-  if (existsSync(LEGACY_HOME_CAPABILITIES_DIR)) console.log(`  WARNING: legacy ~/.oats/capabilities exists and is no longer discovered — reinstall its packages at a config scope and remove it`);
-
-  // Workspace model v2: nothing is installed. Doctor reports the lock (v3) and
-  // the deployment declaration OFFLINE — membership, discovery and package
-  // resolution go to the remotes and belong to `oats sync` / `oats workspace status`.
+  const composition = await doctorComposition(ctx, soulName, ws, (code, msg) => die(`${msg} [${code}]`));
   printDoctorWorkspace(ws);
-
+  for (const p of legacyLayoutProblems(join(dirname(ws.local.path), "agents"))) console.log(`\n! ${p.code}: ${p.message}`);
   if (soulName) {
     const information = operationalKnowledgeNote(composition, soulName);
     if (information) console.log(`\nINFO: ${information}`);
@@ -1448,7 +580,7 @@ function replaceLaunchConfigsBlock(text, serialized) {
   const keyLine = /^(["']?)launch-configs\1:(\s*(?:#.*)?|\s+\S.*)?$/;
   const lines = text.split("\n");
   const starts = lines.map((l, i) => keyLine.test(l) ? i : -1).filter((i) => i >= 0);
-  if (starts.length > 1) throw Object.assign(new Error(`oats-config.yaml declares launch-configs ${starts.length} times (lines ${starts.map((i) => i + 1).join(", ")}); keep one`), { code: "E_CONFIG_BROKEN" });
+  if (starts.length > 1) throw Object.assign(new Error(`oats-local.yaml declares launch-configs ${starts.length} times (lines ${starts.map((i) => i + 1).join(", ")}); keep one`), { code: "E_CONFIG_BROKEN" });
   const block = serialized ? serialized.replace(/\n$/, "").split("\n") : [];
   if (!starts.length) {
     if (!serialized) return text;
@@ -1513,11 +645,9 @@ function normalizeLaunchConfig(e) {
     ...(e.yolo !== undefined ? { yolo: e.yolo } : {}),
   };
 }
-function readLaunchConfigsModel(file) {
-  if (!existsSync(file)) return {};
-  const cfg = withConfigFile(file, () => parseYamlNested(readFileSync(file, "utf8")));
-  const map = cfg["launch-configs"] || {};
-  for (const [name, entry] of Object.entries(map)) validateLaunchConfig(name, entry, file);
+function readLaunchConfigsModel(local) {
+  const map = local["launch-configs"] || {};
+  for (const [name, entry] of Object.entries(map)) validateLaunchConfig(name, entry, "oats-local.yaml");
   const out = Object.create(null); // a name may be "constructor": membership is own only
   for (const [n, e] of Object.entries(map)) out[n] = normalizeLaunchConfig(e);
   return out;
@@ -1551,10 +681,8 @@ function launchConfigContext(bail) {
     if (soulFlag === true) bail("E_BAD_ARGS", "--soul needs a soul name");
     const agentsRootFlag = flag("agents-root");
     if (agentsRootFlag === true) bail("E_BAD_ARGS", "--agents-root needs an absolute agents directory");
-    let r;
-    try { r = resolveOatsConfig(ctx); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
     let soul;
-    try { soul = selectSoul(scopeSouls(ctx, r).souls, String(soulFlag), agentsRootFlag, ctx); } catch (e) { bail(e.code || "E_SOUL_UNKNOWN", e.message); }
+    try { soul = selectSoul(scopeSouls(ctx).souls, String(soulFlag), agentsRootFlag, ctx); } catch (e) { bail(e.code || "E_SOUL_UNKNOWN", e.message); }
     return { context: memberContextOf(soul, ctx, flag("dir") !== undefined, bail), selected: { soul: soul.name, agentsRoot: soul.agentsRoot } };
   }
   return { context: ctx, selected: null };
@@ -1577,25 +705,25 @@ function launchPreview(bail) {
     instance = meta.instance || basename(home);
     if (!(meta.launch && typeof meta.launch === "object") && !selectionGiven) {
       // A home that predates recipes, asked nothing: its frozen command is
-      // described as is. Under a selection it goes through the planner,
-      // whose narrow conversion is the one session restart uses.
+      // described as is. Under a selection the planner refuses it
+      // (E_LAUNCH_LEGACY: re-spawn it from the deployment).
       let d;
       try { d = describeLaunchCommand(meta.command); } catch (e) { bail(e.code || "E_LAUNCH_COMMAND_UNSUPPORTED", e.message); }
-      jsonOk({ context, selected, selection: { source: "frozen-command", launchConfig: null, runtime: null, model: null, yolo: null }, runtime: meta.runtime, model: meta.model || null, modelSource: meta.model ? "recorded" : "native default", yolo: meta.yolo ?? null, launchConfig: null, launchConfigSource: null, executable: { path: d.executable, declared: null, resolvedFrom: "recorded" }, argv: d.argv, environment: d.environment, command: redactLaunchCommand(meta.command), prompt: { kind: "task-file", file: "TASK.md" }, hooks: null, preflight: [{ check: "recipe", ok: true, detail: "frozen command; conversion on restart" }], ok: true });
+      jsonOk({ context, selected, selection: { source: "frozen-command", launchConfig: null, runtime: null, model: null, yolo: null }, runtime: meta.runtime, model: meta.model || null, modelSource: meta.model ? "recorded" : "native default", yolo: meta.yolo ?? null, launchConfig: null, launchConfigSource: null, executable: { path: d.executable, declared: null, resolvedFrom: "recorded" }, argv: d.argv, environment: d.environment, command: redactLaunchCommand(meta.command), prompt: { kind: "task-file", file: "TASK.md" }, hooks: null, preflight: [{ check: "recipe", ok: true, detail: "frozen command; a selection is refused (E_LAUNCH_LEGACY): re-spawn it" }], ok: true });
       return;
     }
     const agentsRoot = agentsRootOfHome(home);
     const agent = (() => { try { return findAgent(agentsRoot, meta.agent); } catch { return undefined; } })();
     agentLike = agent || { runtime: meta.runtime, model: meta.model, yolo: meta.yolo };
   } else {
-    let r0;
-    try { r0 = resolveOatsConfig(context); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-    const soul = scopeSouls(context, r0).souls.find((x) => x.name === selected.soul && x.agentsRoot === selected.agentsRoot);
-    agentLike = { runtime: soul.runtime, model: soul.model, yolo: soul.yolo, "launch-config": soul.launchConfig };
+    const soul = scopeSouls(context).souls.find((x) => x.name === selected.soul && x.agentsRoot === selected.agentsRoot);
+    agentLike = { runtime: soul.runtime, model: soul.model };
     instance = `${soul.name}-<purpose>`; home = join(selected.agentsRoot, soul.name, "instances", instance);
   }
+  // A home's recorded capabilities; a new instance's are its spawn's resolution,
+  // which a preview of a soul does not prepare (spawn --preview does).
   let r;
-  try { r = resolveOatsConfig(context, selected.soul || meta?.agent); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
+  try { r = meta ? resolvedFromHome(home, meta) : { capabilities: [], launchConfigs: launchConfigsAt(context) }; } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message, e.details); }
   // The same planner a start uses, in preview mode: failed checks are listed, nothing is touched.
   let plan;
   try { plan = planLaunch({ home, instance, meta, contextDir: context, agentLike, selection: sel, resolvedCfg: r, preview: true }); } catch (e) { bail(e.code || "E_BAD_ARGS", e.message); }
@@ -1606,40 +734,46 @@ function launchPreview(bail) {
   jsonOk({ context, selected, selection: { source: plan.selectionSource, launchConfig: recipe.launchConfig, runtime: sel.runtime ?? null, model: sel.model ?? null, yolo: sel.yolo ?? null }, runtime: plan.runtime, model: recipe.model, modelSource: plan.modelSource, yolo: recipe.yolo ?? null, launchConfig: recipe.launchConfig, launchConfigSource: recipe.launchConfigSource, executable: { path: plan.executable.path, declared: plan.executable.declared ?? null, resolvedFrom: plan.executable.resolvedFrom }, argv: d.argv, environment, command, prompt: recipe.prompt, hooks: redactLaunchRecipe(recipe).hooks, preflight: plan.preflight, ok: plan.ok });
 }
 async function launchConfigCmd() {
-  const bail = (code, msg) => (JSON_MODE ? jsonFail(code, msg) : die(msg));
+  const bail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
   dropAmbientRoot();
   const sub = args[1];
   const usage = "usage: oats launch-config list [--dir <scope> | --home <abs> | --soul <name> [--dir <scope>] [--agents-root <abs>]] [--json] | set <name> --file <json> [--keep-env] [--dir <scope>] [--json] | remove <name> [--dir <scope>] [--json] | preview (--home <abs> | --soul <name> [--dir <scope>]) [--launch-config <name>|none] [--runtime r] [--model m] [--yolo|--no-yolo] --json";
   if (sub === "preview") { launchPreview(bail); return; }
   if (!["list", "set", "remove"].includes(sub)) bail("E_USAGE", usage);
   const { context: dir, selected } = sub === "list" ? launchConfigContext(bail) : { context: dirFlag(), selected: null };
-  if (sub !== "list" && (flag("home") !== undefined || flag("soul") !== undefined)) bail("E_BAD_ARGS", `launch-config ${sub} writes one scope's oats-config.yaml: address it with --dir, not --home or --soul`);
-  const level = levelOf(dir);
-  const file = join(dir, "oats-config.yaml");
-  const effective = () => {
-    const r = resolveOatsConfig(dir);
-    return Object.values(r.launchConfigs || {}).sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({ name: e.name, ...publicLaunchConfig(e, { source: e.source, shadows: e.shadows }) }));
-  };
+  if (sub !== "list" && (flag("home") !== undefined || flag("soul") !== undefined)) bail("E_BAD_ARGS", `launch-config ${sub} writes the deployment's oats-local.yaml: address it with --dir, not --home or --soul`);
+  // Lead decision 2: launch configurations are a HOST choice, declared in the
+  // deployment's oats-local.yaml (found walking up; a home's own deployment).
+  const at = selected?.home ?? dir;
+  // A 0.25 oats-config.yaml in reach is refused by loadLocal (E_CONFIG_BROKEN, naming
+  // the move), never read as "no configurations".
+  let found = null;
+  // No deployment in reach answers the (empty) effective set — unless what is in
+  // reach is a 0.25 oats-config.yaml, whose launch-configs nothing reads any more.
+  try { found = loadLocal(at); } catch (e) { if (e?.code !== "E_LOCAL_MISSING" || e.details?.legacy) bail(e.code || "E_WORKSPACE_SCHEMA", e.message, e.details); }
+  const file = found?.path ?? null, level = file ? dirname(file) : null;
+  const effective = () => Object.values(launchConfigsAt(at)).sort((a, b) => a.name.localeCompare(b.name)).map((e) => ({ name: e.name, ...publicLaunchConfig(e, { source: e.source, shadows: e.shadows }) }));
   if (sub === "list") {
     let configurations;
-    try { configurations = effective(); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-    if (JSON_MODE) { jsonOk({ context: dir, level, file: existsSync(file) ? file : null, selected, configurations }); return; }
-    if (!configurations.length) { console.log(`No launch configurations are effective at ${dir}`); return; }
+    try { configurations = effective(); } catch (e) { bail(e.code || "E_LAUNCH_CONFIG_INVALID", e.message); }
+    if (JSON_MODE) { jsonOk({ context: dir, level, file, selected, configurations }); return; }
+    if (!configurations.length) { console.log(`No launch configurations are declared${file ? ` in ${shortPath(file)}` : ` (no oats-local.yaml in reach of ${dir})`}`); return; }
     for (const c of configurations) {
       const env = Object.entries(c.env).map(([n, v]) => v.fromEnv ? `${n}=$${v.fromEnv}` : `${n}=<redacted>`).join(" ");
-      console.log(`${c.name}: ${c.runtime}${c.executable ? ` ${c.executable}` : ""}${c.args.length ? ` ${c.args.map((a) => JSON.stringify(a)).join(" ")}` : ""}${env ? ` [${env}]` : ""}${c.model ? ` model ${c.model}` : ""}${c.yolo !== null ? ` yolo ${c.yolo}` : ""}  (${c.source}${c.shadows.length ? `; shadows ${c.shadows.join(", ")}` : ""})`);
+      console.log(`${c.name}: ${c.runtime}${c.executable ? ` ${c.executable}` : ""}${c.args.length ? ` ${c.args.map((a) => JSON.stringify(a)).join(" ")}` : ""}${env ? ` [${env}]` : ""}${c.model ? ` model ${c.model}` : ""}${c.yolo !== null ? ` yolo ${c.yolo}` : ""}`);
     }
     return;
   }
+  if (!file) bail("E_LOCAL_MISSING", `launch-config ${sub} writes the deployment's oats-local.yaml, and none is in reach of ${dir} — run it from the deployment (\`oats onboard\` creates one)`);
   const name = args[2];
   if (!name || name.startsWith("--")) bail("E_BAD_ARGS", `launch-config ${sub} needs a configuration name`);
-  const text = existsSync(file) ? readFileSync(file, "utf8") : `name: ${scaffoldConfigName(dir)}\n`;
+  const text = readFileSync(file, "utf8");
   let model;
-  try { model = readLaunchConfigsModel(file); } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
+  try { model = readLaunchConfigsModel(found.local); } catch (e) { bail(e.code || "E_LAUNCH_CONFIG_INVALID", e.message); }
   const declaredHere = Object.hasOwn(model, name);
   const before = declaredHere ? publicLaunchConfig(model[name]) : null;
   if (sub === "remove") {
-    if (!declaredHere) bail("E_LAUNCH_CONFIG_UNKNOWN", `${name} is not declared at ${level} level (${shortPath(file)}); an inherited configuration is removed at the scope that declares it`);
+    if (!declaredHere) bail("E_LAUNCH_CONFIG_UNKNOWN", `${name} is not declared in ${shortPath(file)}`);
     delete model[name];
   } else {
     const f = flag("file");
@@ -1659,13 +793,11 @@ async function launchConfigCmd() {
     try { entry = JSON.parse(raw); } catch { bail("E_BAD_ARGS", `--file ${f} is not valid JSON (one object with runtime and optional executable, args, env, model, yolo)`); }
     if (args.includes("--keep-env")) {
       // An editor that saw only redacted values keeps the environment of the
-      // definition EFFECTIVE at this scope for that name (this scope's own, or
-      // the inherited one it is overriding): a one-time copy into the complete
-      // replacement entry, not inheritance; whole-entry shadowing stays.
-      if (entry && typeof entry === "object" && entry.env !== undefined) bail("E_BAD_ARGS", "--keep-env keeps the environment of the effective definition; omit env from --file");
-      let current;
-      try { const all = resolveOatsConfig(dir).launchConfigs || {}; current = Object.hasOwn(all, name) ? all[name] : undefined; } catch (e) { bail(e.code || "E_CONFIG_BROKEN", e.message); }
-      if (!current) bail("E_LAUNCH_CONFIG_UNKNOWN", `--keep-env: no launch configuration ${name} is effective at ${dir}, so there is no environment to keep; declare it with env`);
+      // declared definition of that name: a one-time copy into the complete
+      // replacement entry.
+      if (entry && typeof entry === "object" && entry.env !== undefined) bail("E_BAD_ARGS", "--keep-env keeps the environment of the declared definition; omit env from --file");
+      const current = declaredHere ? model[name] : undefined;
+      if (!current) bail("E_LAUNCH_CONFIG_UNKNOWN", `--keep-env: no launch configuration ${name} is declared in ${shortPath(file)}, so there is no environment to keep; declare it with env`);
       if (entry && typeof entry === "object" && Object.keys(current.env || {}).length) entry.env = { ...current.env };
     }
     try { validateLaunchConfig(name, entry, `--file ${f}`); } catch (e) { bail(e.code || "E_LAUNCH_CONFIG_INVALID", e.message); }
@@ -1676,7 +808,10 @@ async function launchConfigCmd() {
   // What is written must read back as exactly what was asked, by the kernel's
   // own reader, before a byte of the file changes.
   let readBack;
-  try { readBack = parseYamlNested(next)["launch-configs"] || {}; } catch (e) { bail("E_LAUNCH_CONFIG_INVALID", `the rewritten block does not parse: ${e.message}; nothing was written`); }
+  let nextLocal;
+  try { nextLocal = parseConfigData(next, { origin: { kind: "local", path: file } }).value; readBack = nextLocal["launch-configs"] || {}; } catch (e) { bail("E_LAUNCH_CONFIG_INVALID", `the rewritten block does not parse: ${e.message}; nothing was written`); }
+  const schemaProblems = validateLocal(nextLocal);
+  if (schemaProblems.length) bail("E_LAUNCH_CONFIG_INVALID", `the rewritten oats-local.yaml would be invalid (${schemaProblems.map((p) => `${p.path || "/"}: ${p.message}`).join("; ")}); nothing was written`);
   const canonical = (m) => JSON.stringify(Object.keys(m).sort().map((n) => [n, normalizeLaunchConfig(m[n])]));
   const same = canonical(readBack) === canonical(model);
   if (!same) bail("E_LAUNCH_CONFIG_INVALID", `${name} would not read back as written; nothing was written`);
@@ -1685,7 +820,7 @@ async function launchConfigCmd() {
   try { eff = effective().find((c) => c.name === name) || null; } catch (e) { eff = { error: e.message }; }
   const receipt = { name, action: sub, level, file, before, after: Object.hasOwn(model, name) ? publicLaunchConfig(model[name]) : null, effective: eff };
   if (JSON_MODE) { jsonOk(receipt); return; }
-  console.log(sub === "set" ? `Declared launch configuration ${name} at ${level} level (${shortPath(file)})` : `Removed launch configuration ${name} from ${level} level (${shortPath(file)})${eff ? `; ${eff.source} now provides it` : ""}`);
+  console.log(sub === "set" ? `Declared launch configuration ${name} in ${shortPath(file)}` : `Removed launch configuration ${name} from ${shortPath(file)}`);
 }
 
 
@@ -1752,8 +887,7 @@ function instanceCmd() {
   if (home === undefined) {
     let root;
     try { root = ensureRoot(dirFlag()); } catch (e) { return bail(e.code || "E_NO_ROOT", e.message); }
-    let r; try { r = resolveOatsConfig(dirFlag()); } catch (e) { return bail(e.code || "E_CONFIG_BROKEN", e.message); }
-    const roots = [...new Set([root, ...(r.team ? teamAgentRoots(r.team.scope) : [])].map((p) => realOrResolved(p)))];
+    const roots = [realOrResolved(root)];
     const candidates = [];
     for (const rt of roots) for (const hit of findInstanceHomes(rt, name)) candidates.push({ root: rt, agent: hit.agent?.name ?? null, home: hit.home });
     if (!candidates.length) return bail("E_SESSION_UNKNOWN", `no instance ${JSON.stringify(name)} under ${roots.join(", ")}`);
@@ -1783,48 +917,36 @@ function instanceCmd() {
     bail(e.code || "E_GIT_FAILED", e.message, e.observation ? { observation: e.observation } : undefined);
   }
 }
-/** `oats readiness [--soul <name> [--agents-root <abs>]] [--home <abs>] [--verify-signatures] [--policy] [--dir <d>] --json` — K5. */
-function readinessCmd() {
+/** `oats readiness (--soul <name> [--agents-root <abs>] [--dir <d>] | --home <abs>) [--policy] --json` — readinessApi 2. */
+async function readinessCmd() {
   const bail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
   dropAmbientRoot();
-  // A captured incarnation's readiness comes from its retained resolution, not
-  // from the current configuration this command reads; refuse before inspecting.
   const homeArg = flag("home");
-  if (homeArg && homeArg !== true) {
-    let capturedMeta = null; try { capturedMeta = JSON.parse(readFileSync(join(String(homeArg), "instance.json"), "utf8")); } catch { /* computeInspect reports the unreadable home */ }
-    if (capturedMeta?.executionBinding || capturedMeta?.captured) return bail("E_UNSUPPORTED_MODE", `${basename(String(homeArg))} is a captured incarnation: its readiness is the retained resolution's, not the current configuration's (inspect it with oats operation --deployment/--resolution)`, { home: String(homeArg), captured: true });
-  }
-  const inspect = computeInspect({ onFail: bail });
-  if (!inspect) return;
-  const soul = flag("soul") === true ? null : flag("soul") || inspect.selected?.soul || null;
-  const verify = args.includes("--verify-signatures");
-  let catalog = null; try { catalog = describeOfficialCatalog(); catalog = { packages: Object.fromEntries(catalog.packages.map((p) => [p.package, p])) }; } catch { catalog = null; }
-  const deploymentDir = inspect.scope?.context ?? null;
-  // Echo the exact selector this read was made with, so a consumer can bind the
-  // result to its own admitted target without inventing a revision.
-  // Every field is the argument AS GIVEN (no realpath): a consumer compares it
-  // byte-exact with what it sent. The canonical scope is subject.context.
-  const given = (name) => { const v = flag(name); return v && v !== true ? String(v) : null; };
-  const agentsRootArg = given("agents-root"), dirArg = given("dir");
-  const selector = homeArg && homeArg !== true ? { kind: "home", home: String(homeArg), soul, agentsRoot: agentsRootArg }
-    : soul ? { kind: "soul", soul, agentsRoot: agentsRootArg, dir: dirArg }
-    : { kind: "scope", dir: dirArg };
-  const readiness = readinessOf(inspect, { soul, verifySignatures: verify, catalog, deploymentDir, selector });
-  if (args.includes("--policy")) {
-    const homeOpt = flag("home");
-    let meta = null;
-    if (homeOpt && homeOpt !== true) { try { meta = JSON.parse(readFileSync(join(homeOpt, "instance.json"), "utf8")); } catch (e) { return bail("E_SESSION_UNKNOWN", `${homeOpt}: ${e.message}`); } }
-    readiness.policy = policyOf({ instanceMeta: meta, soul: soul ? inspect.souls.find((s) => s.name === soul) : null }).policy;
-    readiness.notes.push("policy: a lifecycle-authority claim enforced by the spawn route, not an OS sandbox");
-  }
-  if (JSON_MODE) { jsonOk(readiness); return; }
-  console.log(`readiness — ${readiness.subject.kind === "soul" ? `soul ${readiness.subject.name}` : shortPath(readiness.subject.context)}: ${readiness.summary.ready ? "READY" : `${readiness.summary.fail} failing, ${readiness.summary.unknown} unknown of ${readiness.summary.required} required`}`);
-  for (const [name, check] of Object.entries(readiness.checks)) {
-    console.log(`  ${name}: ${check.status}`);
-    for (const i of check.items) console.log(`    ${i.status.padEnd(14)} ${i.subject}${i.required ? "" : " (optional)"}${i.reason ? ` — ${i.reason}` : ""}${i.signature ? ` · signature ${i.signature.status}${i.signature.signer?.label ? ` by ${i.signature.signer.label}` : ""}` : ""}${i.remedy ? `  → ${i.remedy}` : ""}`);
+  // Workspace model (readinessApi 2): an instance or soul subject; checks
+  // installed | configured | member | providers. No trusted check.
+  if (args.includes("--verify-signatures")) return bail("E_BAD_ARGS", "--verify-signatures was removed with the trusted check (readinessApi 2): declaring a package in packages: is the trust decision, and the lock pins commit + integrity");
+  const target = await workspaceTarget(bail, { command: "readiness" });
+  {
+    const given = (name) => { const v = flag(name); return v && v !== true ? String(v) : null; };
+    const selector = homeArg && homeArg !== true ? { kind: "home", home: String(homeArg), soul: given("soul"), agentsRoot: given("agents-root") }
+      : { kind: "soul", soul: String(flag("soul")), agentsRoot: given("agents-root"), dir: given("dir") };
+    let catalog = null; try { catalog = officialPackageCatalog(); } catch { catalog = null; }
+    const doc = await readinessDocument(target, { selector, remoteOptions: remoteOptionsFromEnv(), catalog });
+    if (args.includes("--policy")) {
+      doc.policy = policyOf({ instanceMeta: target.meta, soul: target.meta ? null : policySoul(target) }).policy;
+      doc.notes.push("policy: a lifecycle-authority claim enforced by the spawn route, not an OS sandbox");
+    }
+    if (JSON_MODE) { jsonOk(doc); return; }
+    const s = doc.subject;
+    console.log(`readiness — ${s.kind === "instance" ? `instance ${s.instance} (soul ${s.soul})` : `soul ${s.soul}`}: ${doc.summary.ready ? "READY" : `${doc.summary.fail} failing, ${doc.summary.unknown} unknown of ${doc.summary.required} required`}`);
+    for (const [name, check] of Object.entries(doc.checks)) {
+      console.log(`  ${name}: ${check.status}`);
+      for (const i of check.items) console.log(`    ${i.status.padEnd(14)} ${i.subject}${i.required ? "" : " (optional)"}${i.reason ? ` — ${i.reason}` : ""}${i.remedy ? `  → ${i.remedy}` : ""}`);
+    }
+    if (doc.policy) console.log(`  policy: child spawns ${doc.policy.childSpawns.allowed ? "allowed" : "disabled"} (${doc.policy.childSpawns.origin.kind}${doc.policy.childSpawns.enforced ? ", enforced" : ""}); worktrees ${doc.policy.worktrees.allowed === null ? "unknown" : doc.policy.worktrees.allowed ? "allowed" : "not in this work mode"}`);
+    for (const n of doc.notes) console.log(`  note: ${n}`);
+    return;
   }
-  if (readiness.policy) console.log(`  policy: child spawns ${readiness.policy.childSpawns.allowed ? "allowed" : "disabled"} (${readiness.policy.childSpawns.origin.kind}${readiness.policy.childSpawns.enforced ? ", enforced" : ""}); worktrees ${readiness.policy.worktrees.allowed === null ? "unknown" : readiness.policy.worktrees.allowed ? "allowed" : "not in this work mode"}`);
-  for (const n of readiness.notes) console.log(`  note: ${n}`);
 }
 // ---------- workspace model v2: sync / package / workspace status / capabilities / souls ----------
 // Contract: docs/design/2026-09-23-workspace-module-contracts.md §6. Nothing is
@@ -1862,12 +984,13 @@ function catalogForSync(bail) {
  *  recomposes the tag from the catalog's own convention.
  *  → { packages: { <id>: <version> }, problems: [ { code: "E_PACKAGE_MISSING", … } ] } */
 function standalonePackages(catalog) {
-  let id = "oats.framework", file = process.env.OATS_PACKAGE_CATALOG || null;
-  try { const d = describeOfficialCatalog(); file = d.catalog.file; id = d.capabilityAliases.find((a) => a.capability === "oats.core")?.package ?? id; } catch { /* the catalog is diagnosed below */ }
+  let id = "oats.framework";
+  const file = officialCatalogFile();
+  try { const alias = officialCapabilityAliases()["oats.core"]; id = (typeof alias === "string" ? alias : alias?.package) ?? id; } catch { /* the catalog is diagnosed below */ }
   const version = standaloneCatalogVersion(catalog?.[id]?.ref);
   if (version) return { packages: { [id]: version }, problems: [] };
   const why = catalog?.[id] ? `its ref ${JSON.stringify(catalog[id].ref)} carries no version` : `it has no entry ${JSON.stringify(id)}`;
-  return { packages: {}, problems: [{ code: "E_PACKAGE_MISSING", id, reason: "no-catalog", catalog: file, path: `/packages/${id}`, message: `the catalog has no package providing oats.core (OATS_PACKAGE_CATALOG=${file ?? "<bundled>"}): ${why}; standalone spawns will be refused until it does` }] };
+  return { packages: {}, problems: [{ code: "E_PACKAGE_MISSING", id, reason: "no-catalog", catalog: file, path: `/packages/${id}`, message: `the catalog has no package providing oats.core (OATS_PACKAGE_CATALOG=${file}): ${why}; standalone spawns will be refused until it does` }] };
 }
 /** The bare version of a catalog ref: its LAST path segment when that is a version
  *  (`v1.1.3` → `v1.1.3`; `oats-framework/v1.1.3` → `v1.1.3`; `main` → null). */
@@ -1889,31 +1012,29 @@ async function discoverForCli(ctx, bail) {
 }
 
 const short = (oid) => (typeof oid === "string" ? oid.slice(0, 8) : "?");
-/** Where a reader takes capability manifests from: the instance home's own
- *  materialized modules when the home has them (workspace model), else the
- *  context directory (classic chain). */
-const manifestSource = (meta, home, ctx) => (meta && meta.modules && typeof meta.modules === "object" && home ? realOrResolved(home) : ctx);
 /** Display name of a discovery: the workspace's name, or the standalone label (decision 10). */
 const workspaceName = (discovery) => discovery.workspace?.name ?? `standalone:${memberLabel(discovery.key)}`;
 const memberLabel = (key) => String(key).split("/").filter(Boolean).pop()?.replace(/\.git$/, "") || String(key);
 const teamLabel = (team) => team ?? "unassigned";
 const originOf = (item) => (item.package ? `package ${item.package} v${item.version}` : `member ${item.repoKey} @ ${short(item.commit)}`);
 
-/** Rows of every non-private soul/capability of confirmed members + locked package capabilities. */
-function workspaceItems(discovery, lock, { includePrivate = false } = {}) {
+/** Rows of every soul and capability of confirmed members (+ external souls) + locked package
+ *  capabilities. Souls have no private mode (0.26.0); a private member capability is listed with
+ *  `private: true` — repo-owned: usable only by its own repo's souls (E_CAPABILITY_PRIVATE). */
+function workspaceItems(discovery, lock) {
   const souls = [];
   const capabilities = [];
   for (const m of discovery.members) {
     if (!m.confirmed && !(discovery.standalone === true && m.key === discovery.key)) continue;
-    for (const s of m.souls) if (includePrivate || !s.private) souls.push({ name: s.name, origin: originOf(s), kind: "member", repoKey: s.repoKey, commit: s.commit, team: teamLabel(s.team), private: s.private, path: s.path, work: s.definition.work ?? null, description: s.definition.description ?? null });
-    for (const c of m.capabilities) if (includePrivate || !c.private) capabilities.push({ name: c.name, origin: originOf(c), kind: "member", repoKey: c.repoKey, commit: c.commit, team: teamLabel(c.team), private: c.private, path: c.path, layer: c.manifest.layer ?? null, version: c.manifest.version ?? null });
+    for (const s of m.souls) souls.push({ name: s.name, origin: originOf(s), kind: "member", repoKey: s.repoKey, commit: s.commit, team: teamLabel(s.team), labels: [...(s.labels ?? (s.team ? [s.team] : []))], private: s.private, path: s.path, work: s.definition.work ?? null, description: s.definition.description ?? null });
+    for (const c of m.capabilities) capabilities.push({ name: c.name, origin: originOf(c), kind: "member", repoKey: c.repoKey, commit: c.commit, team: teamLabel(c.team), private: c.private, path: c.path, layer: c.manifest.layer ?? null, version: c.manifest.version ?? null });
   }
   for (const ext of discovery.external || []) {
     const s = ext.soul;
-    if (includePrivate || !s.private) souls.push({ name: s.name, origin: `external ${s.repoKey} @ ${short(s.commit)}`, kind: "external", repoKey: s.repoKey, commit: s.commit, team: teamLabel(s.team), private: s.private, path: s.path, work: s.definition.work ?? null, description: s.definition.description ?? null });
+    souls.push({ name: s.name, origin: `external ${s.repoKey} @ ${short(s.commit)}`, kind: "external", repoKey: s.repoKey, commit: s.commit, team: teamLabel(s.team), labels: [...(s.labels ?? (s.team ? [s.team] : []))], private: s.private, path: s.path, work: s.definition.work ?? null, description: s.definition.description ?? null });
   }
   for (const [id, entry] of Object.entries(lock?.packages || {})) {
-    for (const name of entry.capabilities) capabilities.push({ name, origin: originOf({ package: id, version: entry.version }), kind: "package", package: id, version: entry.version, commit: entry.commit, team: teamLabel(null), private: false, approved: !!entry.approved });
+    for (const name of entry.capabilities) capabilities.push({ name, origin: originOf({ package: id, version: entry.version }), kind: "package", package: id, version: entry.version, commit: entry.commit, team: teamLabel(null), private: false });
   }
   const byName = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : a.origin < b.origin ? -1 : a.origin > b.origin ? 1 : 0);
   souls.sort(byName);
@@ -1931,7 +1052,7 @@ function memberRows(discovery) {
 
 /** Package rows for `sync` / `workspace status` from the lock. */
 function packageRows(lock) {
-  return Object.entries(lock.packages).map(([id, p]) => ({ id, version: p.version, source: p.source, commit: p.commit, integrity: p.integrity, capabilities: p.capabilities, approved: p.approved }));
+  return Object.entries(lock.packages).map(([id, p]) => ({ id, version: p.version, source: p.source, commit: p.commit, integrity: p.integrity, capabilities: p.capabilities }));
 }
 
 /** Print a padded table: rows are arrays of strings. */
@@ -1941,55 +1062,17 @@ function printTable(header, rows) {
   for (const r of all) console.log("  " + r.map((c, i) => String(c ?? "").padEnd(widths[i])).join("  ").trimEnd());
 }
 
-/** Executables digest of a locked package, read over the remote at its locked commit. */
-async function lockedExecutablesDigest(id, entry, workspace, catalog, remoteOptions) {
-  // ONE definition of the approval digest (lib/packages.mjs executablesDigestAt) — the
-  // same function resolveSoul re-runs at spawn (M3), so sync and spawn can never disagree.
-  const req = parsePackageRequest(id, workspace.packages[id], catalog);
-  const { digest, executables } = await executablesDigestAt(remoteModule, req.remoteRef, entry.commit, entry.path, entry.capabilities ?? null, { remoteOptions });
-  const targets = executables.map((x) => `${x.capability}: ${x.kind} ${x.name} → ${x.target}`);
-  return { digest, targets };
-}
-
-/** One yes/no question on the terminal (TTY only; the caller checks). Ctrl+D / a closed
- *  stdin at the prompt is "no" (readline rejects the question with AbortError, or simply
- *  closes without an answer — neither is a crash; both are the operator declining). */
-async function askYesNo(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
-  try {
-    const closed = new Promise((resolveClosed) => rl.once("close", () => resolveClosed(null)));
-    const answer = await Promise.race([rl.question(question).catch((e) => { if (e?.code === "ABORT_ERR" || e?.name === "AbortError") return null; throw e; }), closed]);
-    if (answer === null) { process.stderr.write("\n"); return false; }
-    const a = String(answer).trim().toLowerCase();
-    return a === "y" || a === "yes";
-  } finally { rl.close(); }
-}
-
-/** `--approve <id>@<version>` (repeatable) → Map<id, version>. Exactly one "@" splits the two;
- *  the digest is never taken from the operator — it is computed over the locked tree. */
-function approveFlags(bail) {
-  const out = new Map();
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] !== "--approve") continue;
-    const v = args[i + 1];
-    if (v === undefined || v.startsWith("--")) return bail("E_BAD_ARGS", "--approve needs <id>@<version> (the package id and the version exactly as `packages:` / the lock spell them)");
-    const at = v.indexOf("@");
-    const id = at > 0 ? v.slice(0, at) : "";
-    const version = at > 0 ? v.slice(at + 1) : "";
-    if (!id || !version || version.includes("@")) return bail("E_BAD_ARGS", `--approve ${JSON.stringify(v)}: expected <id>@<version>`, { value: v });
-    if (out.has(id) && out.get(id) !== version) return bail("E_BAD_ARGS", `--approve names ${id} twice with different versions (${out.get(id)}, ${version})`, { id, versions: [out.get(id), version] });
-    out.set(id, version);
-    i++;
-  }
-  return out;
-}
+/** `--approve` left with package approval (human decision 2026-09-24). */
+const APPROVAL_REMOVED = "package approval was removed; declaring a package in packages: is the trust decision";
 
 /** The body of `oats sync` — shared by `sync` and `onboard` (which onboards, then syncs the same
  * way). Given a v2 deployment context: discover over the remotes, confirm membership, resolve
- * `packages:` against the lock, approve (TTY) or list what needs approval, write the lock.
+ * `packages:` against the lock (commit + integrity), write the lock. There is no approval step:
+ * declaring a package in `packages:` is the trust decision (human decision 2026-09-24).
  * `bail` never returns (it exits the process with the caller's error shape).
- * → { report, lock, discovery, approvalNeeded, interactive, items, lockFile } */
+ * → { report, lock, discovery, items, lockFile, problems } */
 async function performSync(ctx, bail, { onDiscovered } = {}) {
+  if (args.includes("--approve")) return bail("E_BAD_ARGS", `--approve: ${APPROVAL_REMOVED}`, { flag: "--approve" });
   const catalog = catalogForSync(bail);
   const discovery = await discoverForCli(ctx, bail);
   onDiscovered?.(discovery);
@@ -2007,37 +1090,7 @@ async function performSync(ctx, bail, { onDiscovered } = {}) {
     if (typeof e?.code === "string" && e.code.startsWith("E_")) return bail(e.code, e.message, e.details ?? e.provenance);
     throw e;
   }
-  let lock = resolved.lock;
-  const approvalNeeded = [];
-  const interactive = !JSON_MODE && process.stdin.isTTY && process.stdout.isTTY;
-  // `--approve <id>@<version>`: approve what is THERE — every named pair must be a locked entry
-  // at exactly that version (E_BAD_ARGS otherwise); the digest recorded is the one computed over
-  // the locked tree, never anything the operator typed. Works without a terminal.
-  const approveWanted = approveFlags(bail);
-  for (const [id, version] of approveWanted) {
-    const entry = lock.packages[id];
-    if (!entry) return bail("E_BAD_ARGS", `--approve ${id}@${version}: ${id} is not a package of this ${discovery.standalone === true ? "standalone view" : "workspace"} (locked: ${Object.keys(lock.packages).sort().join(", ") || "none"})`, { id, version, locked: Object.keys(lock.packages).sort() });
-    if (entry.version !== version) return bail("E_BAD_ARGS", `--approve ${id}@${version}: the lock resolves ${id} to version ${entry.version} (@ ${short(entry.commit)}) — approve what is there: --approve ${id}@${entry.version}`, { id, version, locked: entry.version, commit: entry.commit });
-  }
-  const approvedNow = [];
-  for (const id of Object.keys(lock.packages)) {
-    const entry = lock.packages[id];
-    if (entry.approved) continue;
-    let digest, targets;
-    try { ({ digest, targets } = await lockedExecutablesDigest(id, entry, packageSource, catalog, ctx.remoteOptions)); }
-    catch (e) {
-      if (typeof e?.code === "string" && e.code.startsWith("E_")) return bail(e.code, e.message, e.details ?? e.provenance);
-      throw e;
-    }
-    if (approveWanted.has(id)) { lock = approvePackage(lock, id, digest); approvedNow.push({ id, version: entry.version, commit: entry.commit, executables: digest, targets }); continue; }
-    if (interactive) {
-      console.error(`\n${id} ${entry.version} @ ${short(entry.commit)} needs executable approval (${targets.length} executable${targets.length === 1 ? "" : "s"}, digest ${digest}):`);
-      for (const t of targets) console.error(`  ${t}`);
-      if (targets.length === 0) console.error("  (no commands or hooks — nothing runs unattended)");
-      if (await askYesNo(`approve ${id} ${entry.version}? [y/N] `)) { lock = approvePackage(lock, id, digest); continue; }
-    }
-    approvalNeeded.push({ id, version: entry.version, commit: entry.commit, executables: digest, targets });
-  }
+  const lock = resolved.lock;
   let lockFile;
   try { lockFile = writeLock(ctx.deploymentDir, lock); } catch (e) { return bail(e.code || "E_LOCK_SCHEMA", e.message, e.details); }
   // The deployment's instance root: <deployment>/agents/ (findRoot's marker). A hand-written
@@ -2046,9 +1099,9 @@ async function performSync(ctx, bail, { onDiscovered } = {}) {
   const members = memberRows(discovery);
   const packages = packageRows(lock);
   const changes = resolved.changes;
-  const items = workspaceItems(discovery, lock, { includePrivate: true });
-  const report = { syncApi: 1, standalone: discovery.standalone === true || undefined, workspace: { name: workspaceName(discovery), key: discovery.key, url: discovery.url, commit: discovery.commit, observedAt: discovery.observedAt, local: ctx.localPath, lock: lockFile }, members, packages, changes, approvalNeeded, ...(approvedNow.length ? { approved: approvedNow } : {}), problems };
-  return { report, lock, discovery, approvalNeeded, approvedNow, interactive, items, lockFile, problems };
+  const items = workspaceItems(discovery, lock);
+  const report = { syncApi: 1, standalone: discovery.standalone === true || undefined, workspace: { name: workspaceName(discovery), key: discovery.key, url: discovery.url, commit: discovery.commit, observedAt: discovery.observedAt, local: ctx.localPath, lock: lockFile }, members, packages, changes, problems, warnings: discovery.warnings ?? [] };
+  return { report, lock, discovery, items, lockFile, problems };
 }
 
 /** The one-line standalone explanation (decision 10). `standaloneReason` says WHY the view is
@@ -2065,32 +1118,28 @@ function standaloneNote(discovery, { from = "" } = {}) {
 
 /** The human §8 report of a sync (text mode). */
 function printSyncReport(ctx, synced) {
-  const { report, discovery, approvalNeeded, interactive, items, lockFile } = synced;
+  const { report, discovery, items, lockFile } = synced;
   const { members, packages, changes } = report;
   const disabled = new Set(ctx.local.souls?.disabled || []);
   console.log(`workspace  ${discovery.workspace?.name ?? `(${standaloneNote(discovery)})`}  (${discovery.key} @ ${short(discovery.commit)})`);
   console.log(`members    ${members.map((m) => m.confirmed ? `${m.name} ✓↔ (@ ${short(m.commit)})` : `${m.name} ✗ (${m.status})`).join("   ") || "(none)"}`);
-  console.log(`packages   ${packages.map((p) => {
-    const need = approvalNeeded.find((a) => a.id === p.id);
-    return `${p.id} ${p.version} ✓ (${p.approved ? "approved" : need ? "approval needed" : "unapproved"})`;
-  }).join("   ") || "(none)"}`);
+  console.log(`packages   ${packages.map((p) => `${p.id} ${p.version} ✓ (@ ${short(p.commit)})`).join("   ") || "(none)"}`);
   const changed = changes.filter((c) => c.to !== null && c.from !== c.to).map((c) => `${c.id}  ${c.from ?? "—"} → ${c.to} (@ ${short(c.commit)})`);
   const removed = changes.filter((c) => c.to === null).map((c) => `${c.id}  ${c.from} → removed`);
   console.log(`changed    ${[...changed, ...removed].join("   ") || "(nothing — the lock already described this workspace)"}`);
   const memberSouls = items.souls.filter((s) => s.kind === "member");
   const externalSouls = items.souls.filter((s) => s.kind === "external");
-  const privateSouls = memberSouls.filter((s) => s.private);
+  // Souls have no private mode (0.26.0); the private count is of repo-owned member capabilities.
+  const repoOwned = items.capabilities.filter((c) => c.kind === "member" && c.private);
   const disabledHere = items.souls.filter((s) => disabled.has(s.name));
-  console.log(`souls      ${items.souls.length} discovered (${memberSouls.length} members, ${externalSouls.length} external, ${disabledHere.length} disabled here) · ${privateSouls.length} private${privateSouls.length ? ` (${privateSouls.map((s) => `${s.name}, ${memberLabel(s.repoKey)} only`).join("; ")})` : ""}`);
+  console.log(`souls      ${items.souls.length} discovered (${memberSouls.length} members, ${externalSouls.length} external, ${disabledHere.length} disabled here) · ${repoOwned.length} private capabilit${repoOwned.length === 1 ? "y" : "ies"}${repoOwned.length ? ` (${repoOwned.map((c) => `${c.name}, ${memberLabel(c.repoKey)} only`).join("; ")})` : ""}`);
   const teams = new Map();
   for (const s of items.souls) { const t = teams.get(s.team) || { souls: 0, capabilities: 0 }; t.souls++; teams.set(s.team, t); }
   for (const c of items.capabilities.filter((c) => c.kind === "member")) { const t = teams.get(c.team) || { souls: 0, capabilities: 0 }; t.capabilities++; teams.set(c.team, t); }
   console.log(`teams      ${[...teams.entries()].sort(([a], [b]) => (a < b ? -1 : 1)).map(([team, n]) => `${team} ${n.souls} soul${n.souls === 1 ? "" : "s"}${n.capabilities ? `, ${n.capabilities} capabilit${n.capabilities === 1 ? "y" : "ies"}` : ""}`).join(" · ") || "(none)"}`);
   for (const p of synced.problems ?? discovery.problems) console.log(`problem    ${p.code}  ${p.repoKey ? `${memberLabel(p.repoKey)}:` : ""}${p.path}  ${p.message}`);
-  for (const a of synced.approvedNow ?? []) console.log(`approved   ${a.id} ${a.version} @ ${short(a.commit)}  (--approve; ${a.targets.length} executable${a.targets.length === 1 ? "" : "s"}, digest ${a.executables})`);
-  if (approvalNeeded.length) {
-    console.log(`\nApproval needed for ${approvalNeeded.map((a) => `${a.id} ${a.version}`).join(", ")} — ${interactive ? "declined; " : "not a terminal; "}the lock records them unapproved. Run \`oats sync\` in a terminal to approve their executables (spawns of souls using them are refused until then).`);
-  } else console.log(`\nlock       ${shortPath(lockFile)}`);
+  for (const w of discovery.warnings ?? []) console.log(`warning    ${w.code}  ${w.message}`);
+  console.log(`\nlock       ${shortPath(lockFile)}`);
 }
 
 /** `oats sync [--dir] [--json]` — contract §6. */
@@ -2098,10 +1147,8 @@ async function syncCmd() {
   const bail = (code, msg, details) => (JSON_MODE ? jsonFail(code, msg, details) : die(msg));
   const ctx = workspaceContext(bail);
   const synced = await performSync(ctx, bail);
-  // One envelope (or the §8 report), then the exit status: 2 = the lock is written but approvals
-  // are pending. exitCode (not process.exit) lets stdout drain when it is a pipe.
+  // One envelope (or the §8 report); success is exit 0 (a failure bails with its code).
   if (JSON_MODE) jsonOk(synced.report); else printSyncReport(ctx, synced);
-  process.exitCode = synced.approvalNeeded.length ? 2 : 0;
 }
 
 /** Walk up from dir for oats-workspace.yaml INSIDE a Git checkout → { file, root } | null. */
@@ -2186,7 +1233,7 @@ async function packageCmd() {
   const receipt = { action: sub, id, value: value ?? null, previous: had ?? null, edited: true, file: checkout.file };
   if (JSON_MODE) { jsonOk(receipt); return; }
   console.log(sub === "add"
-    ? `${had === undefined ? "Added" : `Changed (${had} →)`} packages.${id}: ${value} in ${shortPath(checkout.file)}. Commit it, then \`oats sync\` (the lock resolves the version to a commit and asks approval once).`
+    ? `${had === undefined ? "Added" : `Changed (${had} →)`} packages.${id}: ${value} in ${shortPath(checkout.file)}. Commit it, then \`oats sync\` (the lock resolves the version to a commit).`
     : `Removed packages.${id} (${had}) from ${shortPath(checkout.file)}. Commit it, then \`oats sync\`.`);
 }
 
@@ -2207,8 +1254,7 @@ async function workspaceCmd() {
   const locked = new Set(packages.map((p) => p.id));
   const unsynced = declared.filter((id) => !locked.has(id));
   const stale = packages.filter((p) => !declared.includes(p.id)).map((p) => p.id);
-  const approval = { approved: packages.filter((p) => p.approved).map((p) => p.id), needed: packages.filter((p) => !p.approved).map((p) => p.id) };
-  const result = { workspaceStatusApi: 1, standalone: standalone || undefined, workspace: { name: workspaceName(discovery), key: discovery.key, url: discovery.url, commit: discovery.commit, observedAt: discovery.observedAt, local: ctx.localPath, teams: Object.keys(discovery.workspace?.teams || {}) }, members, packages, declaredPackages: declared, unsynced, stale, approval, external: (discovery.external || []).map((e) => ({ source: e.source, soul: e.soul.name, team: teamLabel(e.soul.team) })), problems: discovery.problems };
+  const result = { workspaceStatusApi: 1, standalone: standalone || undefined, workspace: { name: workspaceName(discovery), key: discovery.key, url: discovery.url, commit: discovery.commit, observedAt: discovery.observedAt, local: ctx.localPath, teams: Object.keys(discovery.workspace?.teams || {}) }, members, packages, declaredPackages: declared, unsynced, stale, external: (discovery.external || []).map((e) => ({ source: e.source, soul: e.soul.name, team: teamLabel(e.soul.team) })), problems: discovery.problems, warnings: discovery.warnings ?? [] };
   if (JSON_MODE) { jsonOk(result); return; }
   console.log(`workspace ${workspaceName(discovery)}  (${discovery.key} @ ${short(discovery.commit)})  local ${shortPath(ctx.localPath)}\n`);
   if (standalone) console.log(`  (${standaloneNote(discovery)})\n`);
@@ -2217,11 +1263,12 @@ async function workspaceCmd() {
   for (const m of members.filter((m) => !m.confirmed)) console.log(`    ${m.name}: ${m.detail}`);
   console.log("\nPackages:");
   if (!packages.length) console.log(unsynced.length ? `  (none locked yet — \`oats sync\` resolves ${unsynced.join(", ")})` : "  (none)");
-  else printTable(["package", "version", "source", "commit", "approval", "capabilities"], packages.map((p) => [p.id, p.version, p.source, short(p.commit), p.approved ? `approved ${p.approved.at.slice(0, 10)}` : "NEEDED", p.capabilities.join(",")]));
+  else printTable(["package", "version", "source", "commit", "capabilities"], packages.map((p) => [p.id, p.version, p.source, short(p.commit), p.capabilities.join(",")]));
   if (packages.length && unsynced.length) console.log(`  declared but not locked (run \`oats sync\`): ${unsynced.join(", ")}`);
   if (stale.length) console.log(`  locked but no longer declared (run \`oats sync\`): ${stale.join(", ")}`);
   if (result.external.length) console.log(`\nExternal: ${result.external.map((e) => `${e.soul} (${e.source.replace(/@([0-9a-f]{40})$/, (_, o) => `@${short(o)}`)}, ${e.team})`).join("   ")}`);
   if (discovery.problems.length) { console.log("\nProblems:"); for (const p of discovery.problems) console.log(`  ${p.code}  ${p.repoKey ? `${memberLabel(p.repoKey)}:` : ""}${p.path}  ${p.message}`); }
+  if (discovery.warnings?.length) { console.log("\nWarnings:"); for (const w of discovery.warnings) console.log(`  ${w.code}  ${w.message}`); }
 }
 
 /** `oats capabilities` / `oats souls` [--dir] [--json] — contract §6. */
@@ -2236,8 +1283,8 @@ async function itemsCmd(kind) {
   if (JSON_MODE) { jsonOk({ [`${kind}Api`]: 1, standalone: standalone || undefined, workspace: { name: workspaceName(discovery), key: discovery.key, commit: discovery.commit }, [kind]: items, problems: discovery.problems }); return; }
   console.log(`${kind} of workspace ${workspaceName(discovery)} (${discovery.key} @ ${short(discovery.commit)})${standalone ? `  — ${standaloneNote(discovery)}` : ""}\n`);
   if (!items.length) console.log("  (none)");
-  else if (kind === "souls") printTable(["name", "origin", "team", "work"], items.map((s) => [s.name, s.origin, s.team, s.work ?? "—"]));
-  else printTable(["name", "origin", "team", "layer"], items.map((c) => [c.name, c.origin, c.team, c.layer ?? "—"]));
+  else if (kind === "souls") printTable(["name", "origin", "team", "work"], items.map((s) => [s.name, s.origin, s.labels?.length > 1 ? s.labels.join(",") : s.team, s.work ?? "—"]));
+  else printTable(["name", "origin", "team", "layer"], items.map((c) => [c.private ? `${c.name} (repo-owned)` : c.name, c.origin, c.team, c.layer ?? "—"]));
   const unsynced = Object.keys(discovery.workspace?.packages || {}).filter((id) => !lock.packages[id]);
   if (kind === "capabilities" && unsynced.length) console.log(`\n  package capabilities of ${unsynced.join(", ")} appear after \`oats sync\``);
 }
@@ -2252,7 +1299,13 @@ async function itemsCmd(kind) {
  *  present) to its stamp — the roster's `repo:` column for a workspace soul. */
 async function statusDrift(data) {
   let ctx;
-  try { ctx = loadLocal(dirFlag()); } catch (e) { if (e?.code === "E_LOCAL_MISSING") return null; throw e; }
+  try { ctx = loadLocal(dirFlag()); }
+  catch (e) {
+    if (e?.code === "E_LOCAL_MISSING") return null;
+    // A 0.25 oats-config.yaml inside the deployment: the typed migration error, never a stack.
+    if (e?.code === "E_CONFIG_BROKEN") { if (JSON_MODE) jsonFail(e.code, e.message, e.details); die(e.message); }
+    throw e;
+  }
   const hasModules = (i) => i.modules && typeof i.modules === "object" && Object.keys(i.modules).length > 0;
   const hasSoul = (i) => i.workspace && typeof i.workspace === "object" && i.workspace.soul && typeof i.workspace.soul === "object" && typeof i.workspace.soul.repoKey === "string";
   // Workspace souls of this roster: the stamp ensureWorkspaceSoul leaves beside the soul pointer.
@@ -2316,13 +1369,14 @@ function soulRepoLabel(a, ws) {
 const short7 = (oid) => (typeof oid === "string" ? oid.slice(0, 7) : "?");
 
 async function status() {
-  if (args.includes("--team")) return statusTeam();
+  if (args.includes("--team")) { const msg = "status --team was removed with the classic team scope: `oats status` in the deployment lists every instance, and `oats workspace status` shows the members"; if (JSON_MODE) jsonFail("E_BAD_ARGS", msg); die(msg); }
   let root;
   try { root = ensureRoot(dirFlag()); }
   catch (e) { if (e?.code === "E_NO_DEPLOYMENT") { if (JSON_MODE) jsonFail("E_NO_DEPLOYMENT", e.message, e.details ?? e.provenance); die(e.message); } throw e; }
   const data = listInstances(root);
   const ws = await statusDrift(data);
   const verbose = args.includes("--verbose");
+  const problems = legacyLayoutProblems(root);
   if (args.includes("--json")) {
     if (ws) for (const a of data) {
       const stamp = ws.souls.get(a.name);
@@ -2335,13 +1389,14 @@ async function status() {
         if (s) i.soul = { repoKey: s.repoKey, commit: s.commit, current: s.current?.commit ?? null, status: s.status, ...(s.reason ? { reason: s.reason } : {}) };
       }
     }
-    console.log(JSON.stringify({ root, agents: data, ...(ws ? { workspace: ws.unreachable ? { reachable: false, ...ws.unreachable } : { reachable: true } } : {}) }, null, 2)); return;
+    console.log(JSON.stringify({ root, agents: data, ...(ws ? { workspace: ws.unreachable ? { reachable: false, ...ws.unreachable } : { reachable: true } } : {}), ...(problems.length ? { problems } : {}) }, null, 2)); return;
   }
   console.log(`oats status — agents root ${shortPath(root)}\n`);
   if (ws?.unreachable) console.log(`  workspace: unreachable (${ws.unreachable.reason}) — drift unknown\n`);
-  if (data.length === 0) { console.log("  (no agents — create one with `oats create <name>`)"); return; }
+  for (const p of problems) console.log(`  ! ${p.code}: ${p.message}\n`);
+  if (data.length === 0) { console.log("  (no agents — a soul is a member repository's souls/<name>; `oats souls` lists the workspace's)"); return; }
   for (const a of data) {
-    console.log(`  ${a.name}${a.kind === "local" ? " (local)" : ""}  [work: ${a.work || "checkout"}, repo: ${soulRepoLabel(a, ws)}]`);
+    console.log(`  ${a.name}  [work: ${a.work || "checkout"}, repo: ${soulRepoLabel(a, ws)}]`);
     if (a.description) console.log(`      ${a.description}`);
     for (const i of a.instances) {
       console.log(`      • ${i.instance}  ${i.retirePending ? "RETIRING" : i.running ? "RUNNING" : "idle"}  (branch ${i.branch || "?"}, ${i.work || "?"})`);
@@ -2356,29 +1411,6 @@ async function status() {
       console.log(`      ! deferred retirement of ${f.instance} FAILED${f.completedAt ? ` at ${f.completedAt}` : ""}: ${f.error || (f.incomplete || []).join("; ") || "see result file"} — retry with \`oats retire ${f.instance}\``);
     }
   }
-  const defs = listAgentDefs(process.cwd());
-  if (defs.length) console.log(`\n  importable defs: ${defs.map((d) => d.name).join(", ")}`);
-}
-
-function statusTeam() {
-  const ctx = dirFlag();
-  const r = resolveOatsConfig(ctx);
-  if (!r.team) die(`no team declared in the config chain from ${shortPath(ctx)} — add a "team:" block (name, optional id) at the deployment scope`);
-  const roots = teamAgentRoots(r.team.scope);
-  const payload = { team: r.team, roots: [] };
-  for (const root of roots) payload.roots.push({ root, agents: listInstances(root) });
-  if (args.includes("--json")) { console.log(JSON.stringify(payload, null, 2)); return; }
-  console.log(`oats status — team ${r.team.name}${r.team.id ? ` (${r.team.id})` : ""}  [scope: ${shortPath(r.team.scope)}]\n`);
-  if (!roots.length) { console.log("  (no agents/ directories in the team scope)"); return; }
-  for (const { root, agents } of payload.roots) {
-    console.log(`  ${shortPath(root)}`);
-    if (!agents.length) { console.log("    (no agents)"); continue; }
-    for (const a of agents) {
-      console.log(`    ${a.name}${a.kind === "local" ? " (local)" : ""}${a.description ? `  — ${a.description}` : ""}`);
-      for (const i of a.instances) console.log(`      • ${i.instance}  ${i.retirePending ? "RETIRING" : i.running ? "RUNNING" : "idle"}`);
-      for (const f of a.retireFailures || []) console.log(`      ! deferred retirement of ${f.instance} FAILED: ${f.error || (f.incomplete || []).join("; ") || "see result file"} — retry with \`oats retire ${f.instance}\``);
-    }
-  }
 }
 
 async function spawnCmd() {
@@ -2393,90 +1425,96 @@ async function spawnCmd() {
   const checkDirectoryOptions = (work) => {
     if (work === "directory" && (workDir !== undefined || branch !== undefined)) bail("E_BAD_ARGS", "--work directory owns only <home>/work; --work-dir and --branch are not allowed");
   };
-  checkDirectoryOptions(requestedWork); // before a local soul could be upserted
+  checkDirectoryOptions(requestedWork); // before anything is resolved or written
   const name = args[1];
-  if (!name || name.startsWith("--")) bail("E_USAGE", "usage: oats spawn <agent> [--task <text>|--task-file <f>] [--purpose <slug>] [--preview] [--base <ref>] [--model <id>|@native-default] [--allow-child-spawns|--no-child-spawns] [--relation child|sibling|parent|unrelated --relative-to <instance> [--relative-root <agents-root>]] [--parent <instance>] [--repo <r>] [--work worktree|checkout|attached|workspace|directory] [--work-dir <owner-work>] [--runtime pi|claude|codex] [--backend tmux|herdr] [--herdr-socket <path>] [--yolo|--no-yolo] [--model <m>] [--branch <b>] [--instructions-file <f>|--def-file <f>] [--no-launch] [--json]");
+  if (!name || name.startsWith("--")) bail("E_USAGE", "usage: oats spawn <agent> [--task <text>|--task-file <f>] [--purpose <slug>|--name <slug>] [--preview] [--base <ref>] [--model <id>|@native-default] [--allow-child-spawns|--no-child-spawns] [--relation child|sibling|parent|unrelated --relative-to <instance> [--relative-root <agents-root>]] [--parent <instance>] [--repo <r>] [--work worktree|checkout|attached|workspace|directory] [--work-dir <owner-work>] [--runtime pi|claude|codex] [--backend tmux|herdr] [--herdr-socket <path>] [--yolo|--no-yolo] [--model <m>] [--branch <b>] [--no-launch] [--json]");
   // Retired boundary flags (maintainer transport ruling): fail LOUDLY before
-  // ANY side effect — including root discovery and local-agent upsert (an
-  // --instructions-file spawn must not scaffold/overwrite a local soul before
-  // this rejection; reviewer-b671de0).
-  if (args.includes("--instance")) bail("E_BAD_ARGS", "--instance was removed by the runtime-boundary ruling — use --purpose <slug> (deterministic <agent>-<purpose> naming)");
+  // ANY side effect, including root discovery.
+  // Local souls (local-agents/) are gone with the workspace model: a soul is a member
+  // repository's souls/<name>, so spawn never writes one.
+  for (const removed of ["instructions-file", "def-file"]) if (flag(removed) !== undefined) bail("E_BAD_ARGS", `--${removed} created a local soul under local-agents/, which the workspace model removed — author souls/<name>/soul.yaml + AGENTS.md in a member repository, then \`oats sync\``);
+  if (args.includes("--instance")) bail("E_BAD_ARGS", "--instance was removed by the runtime-boundary ruling — use --purpose <slug> (deterministic <agent>-<purpose> naming) or --name <slug> (the exact instance name)");
+  // --name <slug>: the exact, unprefixed instance name (human decision 2026-09-24).
+  const nameFlag = flag("name");
+  if (nameFlag === true) bail("E_BAD_ARGS", "--name needs an instance name (a slug: lowercase letters and digits, single dashes between them)");
+  if (nameFlag !== undefined && flag("purpose") !== undefined) bail("E_BAD_ARGS", "--name and --purpose are mutually exclusive: --name is the exact instance name, --purpose derives <agent>-<purpose>");
+  // The slug rule is checked here too, before any side effect (soul fetch).
+  if (nameFlag !== undefined) { try { explicitInstanceName(String(nameFlag)); } catch (e) { bail(e.code, e.message); throw e; } }
   if (args.includes("--ephemeral")) bail("E_BAD_ARGS", "--ephemeral was removed by the runtime-boundary ruling — declare the agent in a capability manifest (agents:) for automatic ephemeral semantics");
   let root;
+  // A spawn needs a workspace deployment (lead decision c3-1): no oats-local.yaml
+  // in reach is E_LOCAL_MISSING, before anything else is read. The agents root is
+  // then <deployment>/agents; an ambient root (the invoking agent's own
+  // PI_AGENTS_ROOT / OATS_ROOT) never redirects it — a home outside
+  // <deployment>/agents would have no derivable deployment.
+  try { loadLocal(dirFlag()); } catch (e) { if (e?.code === "E_LOCAL_MISSING") bail("E_LOCAL_MISSING", `${e.message}: a spawn needs a workspace deployment — \`oats onboard\` creates one`, e.details); else bail(e.code || "E_WORKSPACE_SCHEMA", e.message, e.details); }
+  delete process.env.PI_AGENTS_ROOT; delete process.env.OATS_ROOT;
+  // A deployment without its agents/ root is E_NO_DEPLOYMENT, naming the remedy.
   try { root = ensureRoot(dirFlag()); }
   catch (e) { bail("E_NO_DEPLOYMENT", e.message || e); throw e; }
   const isPreview = args.includes("--preview");
   // --agents-root <abs>: the exact root the soul must live in (as inspect and
-  // readiness take it). With it, no team-soul / capability-agent / importable-
-  // def fallback: the soul is there or the spawn refuses E_SOUL_UNKNOWN.
+  // readiness take it) — the deployment's one agents root, or E_SOUL_UNKNOWN.
   const agentsRootFlag = flag("agents-root");
   if (agentsRootFlag !== undefined && (agentsRootFlag === true || !isAbsolute(String(agentsRootFlag)))) bail("E_BAD_ARGS", "--agents-root needs an absolute agents root");
-  if (agentsRootFlag !== undefined && realOrResolved(String(agentsRootFlag)) !== realOrResolved(root)) {
-    const teamHit = findTeamAgent(dirFlag(), name), hit = (teamHit?.matches || []).find((m) => realOrResolved(m.root) === realOrResolved(String(agentsRootFlag)));
-    if (!hit) bail("E_SOUL_UNKNOWN", `soul "${name}" is not at agents root ${String(agentsRootFlag)} (this scope's root is ${shortPath(root)})`);
-    root = hit.root;
-  }
+  if (agentsRootFlag !== undefined && realOrResolved(String(agentsRootFlag)) !== realOrResolved(root)) bail("E_SOUL_UNKNOWN", `soul "${name}" is not at agents root ${String(agentsRootFlag)} (this scope's root is ${shortPath(root)})`);
   let agent = findAgent(root, name);
   // Workspace model: with an oats-local.yaml the soul is ALWAYS discovered over the
-  // remotes and resolved (member = latest state, package = locked+approved) — never
+  // remotes and resolved (member = latest state, package = locked) — never
   // "whatever <agents-root>/<name>/soul/ happens to hold": that copy is a per-commit
   // cache (ensureWorkspaceSoul refreshes it when the member moved), so a second
   // spawn sees the member's CURRENT soul, not the first spawn's. A preview runs the
-  // same read-only discovery+resolution; the fetched soul copy it may leave under
-  // <agents-root>/<name>/soul/ is not an instance (reported as soulFetched).
+  // same read-only discovery+resolution and writes nothing: it reads the soul from
+  // the per-commit cache, or fetches it to a temporary copy (reported as soulFetched).
   const providerPairs = [];
   for (let i = 0; i < args.length; i++) if (args[i] === "--provider") { if (!args[i + 1] || !args[i + 2]) bail("E_BAD_ARGS", "--provider needs <capability> <key>=<value>"); providerPairs.push([args[i + 1], args[i + 2]]); i += 2; }
-  let wsPrepared, soulFetched = false, wsSoulUnknown = null;
-  let hasLocal = true;
+  let wsPrepared, soulFetched = false, wsSoulUnknown = null, wsDiscovery;
   {
-    try { loadLocal(dirFlag()); } catch (e) { if (e?.code === "E_LOCAL_MISSING") hasLocal = false; else bail(e.code || "E_WORKSPACE_SCHEMA", e.message, e.details); }
-    if (hasLocal) {
-      let discovery = null;
-      try {
-        const { prepareInstance, ensureWorkspaceSoul, parseProviderFlags, discoverOrStandalone } = await import("../lib/instance-resolution.mjs");
-        const remoteOptions = remoteOptionsFromEnv();
-        const { local } = loadLocal(dirFlag());
-        discovery = await discoverOrStandalone(local, { remoteOptions });
-        wsPrepared = await prepareInstance(dirFlag(), name, { spawn: { providers: parseProviderFlags(providerPairs) }, remoteOptions, discovery });
-        const soulName = wsPrepared.soulEntry.name;
+    let discovery = null;
+    try {
+      const { prepareInstance, ensureWorkspaceSoul, previewWorkspaceSoul, parseProviderFlags, discoverOrStandalone } = await import("../lib/instance-resolution.mjs");
+      const remoteOptions = remoteOptionsFromEnv();
+      const { local } = loadLocal(dirFlag());
+      discovery = wsDiscovery = await discoverOrStandalone(local, { remoteOptions });
+      wsPrepared = await prepareInstance(dirFlag(), name, { spawn: { providers: parseProviderFlags(providerPairs) }, remoteOptions, discovery });
+      const soulName = wsPrepared.soulEntry.name;
+      let soulDir;
+      if (isPreview) {
+        // A preview writes nothing in the deployment: the soul comes from the
+        // per-commit cache when complete, else from a temporary fetch removed at exit.
+        const pv = await previewWorkspaceSoul(wsPrepared, root);
+        process.once("exit", pv.cleanup);
+        soulDir = pv.soulDir; soulFetched = pv.fetched;
+        agent = findAgentAt(root, soulName, soulDir);
+      } else {
         const stampFile = join(root, soulName, ".oats-soul-source.json");
         const stampBefore = (() => { try { return JSON.parse(readFileSync(stampFile, "utf8")); } catch { return null; } })();
-        const soulDir = await ensureWorkspaceSoul(wsPrepared, root);
+        soulDir = await ensureWorkspaceSoul(wsPrepared, root);
         soulFetched = !stampBefore || stampBefore.commit !== wsPrepared.soulEntry.commit || stampBefore.repoKey !== wsPrepared.soulEntry.repoKey;
         if (!agent || soulFetched || agent._dir !== dirname(soulDir)) agent = findAgent(root, soulName);
-        if (!agent) bail("E_SOUL_UNKNOWN", `soul "${name}" was fetched to ${shortPath(soulDir)} but is not readable as a soul there`);
-        note(`(workspace soul: "${name}" from ${wsPrepared.soulEntry.repoKey} @ ${String(wsPrepared.soulEntry.commit).slice(0, 12)}${wsPrepared.soulEntry.team ? `, team ${wsPrepared.soulEntry.team}` : ""}${soulFetched ? "; soul source fetched" : ""})`);
-      } catch (e) {
-        // Standalone (decisions 10/25): the ONLY package request is the kernel's own
-        // default; when the catalog cannot name it, say so instead of "add it to packages:"
-        // (there is no workspace file to add it to).
-        if (e?.code === "E_PACKAGE_MISSING" && discovery?.standalone === true) {
-          let file = process.env.OATS_PACKAGE_CATALOG || null; try { file = describeOfficialCatalog().catalog.file; } catch { /* keep the env value */ }
-          bail(e.code, `${e.details?.capability ?? "oats.core"}: the catalog has no package providing oats.core (OATS_PACKAGE_CATALOG=${file ?? "<bundled>"}) — standalone spawns resolve only the kernel's default package from the catalog`, { ...(e.details ?? {}), standalone: true, reason: "no-catalog", catalog: file });
-        }
-        // Not a workspace soul: a capability-defined agent (a module's `agents:`
-        // soul, resolved below from a materialized copy) or a local-only soul
-        // (--instructions-file/--def-file) may still answer to this name.
-        if (e?.code === "E_SOUL_UNKNOWN" && !isPreview) { wsSoulUnknown = e; }
-        else if (e?.code?.startsWith?.("E_")) bail(e.code, e.message, e.details);
-        else throw e;
       }
-    } else if (providerPairs.length) bail("E_BAD_ARGS", "--provider needs a workspace deployment (oats-local.yaml); this directory has none");
+      if (!agent) bail("E_SOUL_UNKNOWN", `soul "${name}" was fetched to ${shortPath(soulDir)} but is not readable as a soul there`);
+      note(`(workspace soul: "${name}" from ${wsPrepared.soulEntry.repoKey} @ ${String(wsPrepared.soulEntry.commit).slice(0, 12)}${wsPrepared.soulEntry.team ? `, team ${wsPrepared.soulEntry.team}` : ""}${soulFetched ? "; soul source fetched" : ""})`);
+    } catch (e) {
+      // Standalone (decisions 10/25): the ONLY package request is the kernel's own
+      // default; when the catalog cannot name it, say so instead of "add it to packages:"
+      // (there is no workspace file to add it to).
+      if (e?.code === "E_PACKAGE_MISSING" && discovery?.standalone === true) {
+        const file = officialCatalogFile();
+        bail(e.code, `${e.details?.capability ?? "oats.core"}: the catalog has no package providing oats.core (OATS_PACKAGE_CATALOG=${file}) — standalone spawns resolve only the kernel's default package from the catalog`, { ...(e.details ?? {}), standalone: true, reason: "no-catalog", catalog: file });
+      }
+      // Not a workspace soul: a capability-defined agent (a module's `agents:`
+      // soul, resolved below from a materialized copy) may still answer to this name.
+      if (e?.code === "E_SOUL_UNKNOWN" && !isPreview) { wsSoulUnknown = e; }
+      else if (e?.code?.startsWith?.("E_")) bail(e.code, e.message, e.details);
+      else throw e;
+    }
   }
   if (agentsRootFlag !== undefined && !agent) bail("E_SOUL_UNKNOWN", `soul "${name}" is not at agents root ${String(agentsRootFlag)}`);
   if (isPreview && !agent) bail("E_SOUL_UNKNOWN", `soul "${name}" is not in ${shortPath(root)}; a preview never creates or imports a soul (known: ${listAgents(root).map((a) => a.name).join(", ") || "none"})`);
-  if (isPreview && (flag("instructions-file") !== undefined || flag("def-file") !== undefined)) bail("E_BAD_ARGS", "--preview does not take --instructions-file/--def-file: a preview never writes a soul");
-  const instrFile = flag("instructions-file");
-  const defFile = flag("def-file");
-  if (!agent && !instrFile && !defFile) {
-    // Capability-defined agent: a package's `agents:` soul, active in this context.
-    const capAgent = findCapabilityAgent(dirFlag(), root, name);
-    if (capAgent) {
-      agent = capAgent;
-      note(`(capability agent: "${name}" from ${capAgent.capability} — fresh soul, instances home locally)`);
-    }
-  }
-  if (!agent && !instrFile && !defFile && hasLocal) {
+  // Capability agent (lead decision c3 Q1): a prepared spawn of its providing module only.
+  let capabilityPrepared, capabilityPkg = null;
+  if (!agent) {
     // Workspace model: the agent is declared by a capability some INSTANCE already
     // materialized (the --parent home first, then any home under this root) —
     // OKF's memory-harvest worker spawned by a knowledge source, for example.
@@ -2487,50 +1525,30 @@ async function spawnCmd() {
     catch (e) { bail(e.code || "E_CAPABILITY_BROKEN", e.message, e.details); }
     if (modAgent) {
       agent = modAgent;
-      note(`(capability agent: "${name}" from ${modAgent.capability}, materialized in ${shortPath(modAgent._manifestSource)} — fresh soul, instances home locally)`);
+      note(`(capability agent: "${name}" from ${modAgent.capability}, materialized in ${shortPath(modAgent._manifestSource)} — fresh soul, instances home under ${shortPath(join(root, name, "instances"))})`);
     } else {
-      // No instance carries it: resolve from the deployment's LOCK — an approved
+      // No instance carries it: resolve from the deployment's LOCK — a locked
       // package whose capability declares agents/<name> is fetched into the
       // deployment's module store and read from there.
       try {
         const { resolvePackageCapabilityAgent } = await import("../lib/instance-resolution.mjs");
-        const hit = await resolvePackageCapabilityAgent(dirFlag(), name, { remoteOptions: remoteOptionsFromEnv(), catalog: (() => { try { return officialPackageCatalog(); } catch { return null; } })() });
+        const hit = await resolvePackageCapabilityAgent(dirFlag(), name, { remoteOptions: remoteOptionsFromEnv(), discovery: wsDiscovery, catalog: (() => { try { return officialPackageCatalog(); } catch { return null; } })() });
         if (hit) {
           agent = capabilityAgentFromDir(hit.dir, name, root, { module: { from: { kind: "package", package: hit.package, version: hit.version, commit: hit.commit } } });
-          if (agent) note(`(capability agent: "${name}" from ${hit.capability} — package ${hit.package} v${hit.version}, fetched to ${shortPath(hit.dir)} — fresh soul, instances home locally)`);
+          if (agent) { capabilityPkg = hit; note(`(capability agent: "${name}" from ${hit.capability} — package ${hit.package} v${hit.version}, fetched to ${shortPath(hit.dir)} — fresh soul, instances home under ${shortPath(join(root, name, "instances"))})`); }
         }
       } catch (e) { if (e?.code?.startsWith?.("E_")) bail(e.code, e.message, e.details); throw e; }
     }
-  }
-  if (!agent && wsSoulUnknown && !instrFile && !defFile) bail(wsSoulUnknown.code, wsSoulUnknown.message, wsSoulUnknown.details);
-  if (!agent && !instrFile && !defFile) {
-    // Cross-repo lookup: the soul may live in a sibling repo of the team scope.
-    // Unique match wins; the instance homes with its owning repo's agents root.
-    const teamHit = findTeamAgent(dirFlag(), name);
-    const remote = (teamHit?.matches || []).filter((m) => resolve(m.root) !== resolve(root));
-    if (remote.length > 1) bail("E_AMBIGUOUS_SOUL", `soul "${name}" found in multiple team repos: ${remote.map((m) => shortPath(m.root)).join(", ")} — re-run with --dir <that repo>`);
-    if (remote.length === 1) {
-      root = remote[0].root;
-      agent = remote[0].agent;
-      note(`(cross-repo: soul "${name}" found at ${shortPath(root)} — instance homes there)`);
+    if (agent) {
+      try {
+        const { prepareCapabilityAgent } = await import("../lib/instance-resolution.mjs");
+        capabilityPrepared = await prepareCapabilityAgent(dirFlag(), agent, { discovery: wsDiscovery, pkg: capabilityPkg, remoteOptions: remoteOptionsFromEnv(), catalog: (() => { try { return officialPackageCatalog(); } catch { return null; } })() });
+      } catch (e) { if (e?.code?.startsWith?.("E_")) bail(e.code, e.message, e.details); throw e; }
     }
   }
+  if (!agent && wsSoulUnknown) bail(wsSoulUnknown.code, wsSoulUnknown.message, wsSoulUnknown.details);
   checkDirectoryOptions(requestedWork || agent?.work);
-  // local agents: create/update from raw instructions or a single-file def
-  if (instrFile || defFile || !agent) {
-    if (!agent && !instrFile && !defFile) {
-      const def = listAgentDefs(process.cwd()).find((d) => d.name === name);
-      if (!def) bail("E_UNKNOWN_AGENT", `unknown agent "${name}" (known: ${listAgents(root).map((a) => a.name).join(", ") || "none"}; importable defs: ${listAgentDefs(process.cwd()).map((d) => d.name).join(", ") || "none"}) — pass --instructions-file or --def-file to create a local agent`);
-      agent = upsertLocalAgent(root, { name: def.name, file: def.path, repo: flag("repo"), work: flag("work"), runtime: flag("runtime"), model: flag("model"), oatsCore: !args.includes("--no-oats-core") });
-    } else if (!agent || agent.kind === "local") {
-      agent = upsertLocalAgent(root, {
-        name, file: defFile, instructions: instrFile ? readFileSync(instrFile, "utf8") : undefined, oatsCore: !args.includes("--no-oats-core"),
-        repo: flag("repo"), work: flag("work"), runtime: flag("runtime"), model: flag("model"), yolo: yoloFlag(),
-      });
-    } else {
-      bail("E_BAD_ARGS", `"${name}" is a persistent agent — spawn it without --instructions-file/--def-file`);
-    }
-  }
+  if (!agent) bail("E_UNKNOWN_AGENT", `unknown agent "${name}" (known: ${listAgents(root).map((a) => a.name).join(", ") || "none"}) — a soul is a member repository's souls/<name>; add it there and run \`oats sync\``);
   for (const information of agent.notes || []) note(`[${information.code}] ${information.message}`);
   // Lineage is explicit: --relation child|sibling|parent|unrelated anchors the new
   // instance to --relative-to <instance>. --parent X is sugar for
@@ -2558,9 +1576,9 @@ async function spawnCmd() {
   // NOTE: explicit "unrelated" is passed through to the kernel.
   if (relativeTo && relation !== "unrelated") {
     // findInstanceHome also sees capability-defined agents' instance homes
-    // (local-agents/<name>/ without a local soul) — e.g. a reviewer passing
+    // (<root>/<name>/ without a soul) — e.g. a reviewer passing
     // --parent "$OATS_INSTANCE" from a capability agent.
-    if (!findInstanceHome(root, relativeTo) && !findTeamInstance(dirFlag(), relativeTo)) bail(parent ? "E_PARENT_NOT_FOUND" : "E_RELATIVE_NOT_FOUND", `${parent ? "--parent" : "--relative-to"} "${relativeTo}" does not match any known instance`);
+    if (!findInstanceHome(root, relativeTo)) bail(parent ? "E_PARENT_NOT_FOUND" : "E_RELATIVE_NOT_FOUND", `${parent ? "--parent" : "--relative-to"} "${relativeTo}" does not match any known instance`);
   }
   const taskText = flag("task");
   if (taskText === true) bail("E_BAD_ARGS", "--task needs a value (use --task-file for long tasks)");
@@ -2600,7 +1618,7 @@ async function spawnCmd() {
   } catch (e) { if (e?.code?.startsWith?.("E_")) bail(e.code, e.message); throw e; }
   // Workspace model: when this deployment has an oats-local.yaml, the soul's
   // capabilities are resolved over the workspace's remotes (member = latest,
-  // package = locked+approved) and copied whole into the new home. Without one
+  // package = locked) and copied whole into the new home. Without one
   // (a bare agents root, tests) the classic soul-directory spawn proceeds.
   let prepared;
   // Workspace model: a `work: worktree|checkout` soul works IN its member's clone on
@@ -2608,10 +1626,10 @@ async function spawnCmd() {
   // convention <deployment>/<member name>. Never an ambient Git checkout around the
   // deployment. Resolved once here so a preview sees exactly what the apply would.
   let preparedRepo;
-  if (wsPrepared) {
+  if (wsPrepared || capabilityPrepared) {
     try {
       const { toCapabilityRows, modulesPreview, requireMemberClone } = await import("../lib/instance-resolution.mjs");
-      prepared = wsPrepared;
+      prepared = wsPrepared ?? capabilityPrepared;
       prepared.capabilityRows = []; // filled after materialization (paths live in the home); preview uses modulesPreview
       prepared.preview = modulesPreview(prepared.resolution, root, agent.name);
       prepared.toCapabilityRows = toCapabilityRows;
@@ -2625,12 +1643,13 @@ async function spawnCmd() {
     if (flag("base") === true) bail("E_BAD_ARGS", "--base needs a ref");
     { const spawnOpts = {
       prepared,
-      purpose: flag("purpose"), task: taskText, taskFile: taskFileFlag, relation, relativeTo, relativeRoot,
+      purpose: flag("purpose"), ...(nameFlag !== undefined ? { name: String(nameFlag) } : {}), task: taskText, taskFile: taskFileFlag, relation, relativeTo, relativeRoot,
       ...(args.includes("--allow-child-spawns") ? { allowChildSpawns: true } : args.includes("--no-child-spawns") ? { allowChildSpawns: false } : {}),
       // Directory execution uses deployment configuration, not an ambient Git
       // checkout (especially when invoked via --dir from a source instance).
-      repo: preparedRepo !== undefined ? preparedRepo : (requestedWork || agent.work) === "directory"
-        ? (repo ?? agent.repo) : repo || agent.repo || defaultRepo(workspaceOf(root)) || defaultRepo(process.cwd()),
+      // An attached instance's repository is its work tree owner's (derived by the kernel).
+      repo: preparedRepo !== undefined ? preparedRepo : ["directory", "attached"].includes(requestedWork || agent.work)
+        ? repo : repo || defaultRepo(workspaceOf(root)) || defaultRepo(process.cwd()),
       work: requestedWork, workDir, runtime: flag("runtime"), backend, herdrSocket, yolo, model: flag("model"), branch,
       launchConfig: valueFlag("launch-config"),
       launch: !args.includes("--no-launch"),
@@ -2644,13 +1663,13 @@ async function spawnCmd() {
       // K6c: with --idempotency-key, a retry of the SAME confirmed decision replays the recorded home instead of spawning twice.
       ...(flag("idempotency-key") !== undefined && flag("idempotency-key") !== true ? { idempotencyKey: String(flag("idempotency-key")) } : {}),
     };
-      r = prepared ? await spawnInstanceAsync(root, agent, spawnOpts) : spawnInstance(root, agent, spawnOpts); }
+      r = await spawnInstanceAsync(root, agent, spawnOpts); }
     if (args.includes("--preview")) {
-      // A workspace preview may have fetched the soul's SOURCE under <agents-root>/<name>/soul/
-      // (a per-commit cache, not an instance): the result says so.
+      // A workspace preview may have fetched the soul's SOURCE to a temporary copy
+      // (the deployment's cache had no entry for its commit): the result says so.
       if (prepared) r.soulFetched = soulFetched;
       if (JSON_MODE) { jsonOk(r); return; }
-      console.log(`preview ${r.agent} → ${r.instance} (${r.work}${r.branch ? `, branch ${r.branch} from ${r.base.ref}@${r.base.oid.slice(0, 12)}` : ""}) runtime ${r.runtime}${r.model ? ` model ${r.model}` : ` (${r.modelSource})`}; nothing was created${soulFetched ? ` (the soul source was fetched to ${shortPath(join(root, r.agent, "soul"))} — a per-commit copy, not an instance)` : ""}`);
+      console.log(`preview ${r.agent} → ${r.instance} (${r.work}${r.branch ? `, branch ${r.branch} from ${r.base.ref}@${r.base.oid.slice(0, 12)}` : ""}) runtime ${r.runtime}${r.model ? ` model ${r.model}` : ` (${r.modelSource})`}; nothing was created${soulFetched ? " (the soul source was fetched to a temporary copy, not kept)" : ""}`);
       return;
     }
   } catch (e) {
@@ -2672,6 +1691,8 @@ async function spawnCmd() {
     if (e?.code === "E_DECISION_STALE") { bail(e.code, e.message, { decision: e.decision }); throw e; }
     if (e?.code === "E_IDEMPOTENCY_CONFLICT") { bail(e.code, e.message, { instance: e.instance, home: e.home }); throw e; }
     if (e?.code === "E_PLACEMENT_TAKEN") { bail(e.code, e.message, { instance: e.instance, home: e.home }); throw e; }
+    if (e?.code === "E_INSTANCE_NAME_TAKEN") { bail(e.code, e.message, { instance: e.instance, home: e.home ?? null, ...(e.session ? { session: e.session } : {}) }); throw e; }
+    if (e?.code === "E_INSTANCE_NAME_INVALID") { bail(e.code, e.message); throw e; }
     if (e?.code === "E_SPAWN_INCOMPLETE") { bail(e.code, e.message, { instance: e.instance, home: e.home, launched: e.launched }); throw e; }
     bail(["E_BAD_ARGS", "E_RELATIVE_AMBIGUOUS"].includes(e.code) ? e.code : "E_SPAWN_FAILED", e.message || e); throw e;
   }
@@ -2734,7 +1755,7 @@ function retireCmd() {
       console.log(`  defaults: retain worktree ${plan.defaults.retainWorktree}, delete branch ${plan.defaults.deleteBranch}, stop children ${plan.defaults.stopChildren}`);
       for (const n of plan.notes) console.log(`  note: ${n}`);
       return;
-    } catch (e) { return args.includes("--json") ? jsonFail(e.code || "E_LIFECYCLE_FAILED", e.message, e.candidates ? { candidates: e.candidates } : undefined) : die(e.message); }
+    } catch (e) { return args.includes("--json") ? jsonFail(e.code || "E_LIFECYCLE_FAILED", e.message, e.candidates ? { ...e.details, candidates: e.candidates } : e.details) : die(e.message); }
   }
   // The calling instance knows its own home: self-retire never needs to
   // disambiguate a same-named twin by hand.
@@ -2742,13 +1763,7 @@ function retireCmd() {
   const isSelf = process.env.PI_AGENT_INSTANCE === name || process.env.OATS_INSTANCE === name;
   if (isSelf && !args.includes("--self")) die(`"${name}" is the calling instance — self-retire is irreversible; if your task is complete and you were told to retire, re-run with --self (finish your memory files FIRST; your session dies ~8s after)`);
   if (!isSelf && args.includes("--self")) die(`--self given but "${name}" is not the calling instance`);
-  let root = ensureRoot(dirFlag());
-  // Cross-repo: the instance may home in a sibling repo of the team scope.
-  if (!listAgents(root).some((a) => existsSync(join(a._dir, "instances", name)))) {
-    const hit = findTeamInstance(dirFlag(), name);
-    // Stdout carries only the envelope in JSON mode (the Desktop parses it).
-    if (hit && resolve(hit.root) !== resolve(root)) { root = hit.root; (args.includes("--json") ? console.error : console.log)(`(cross-repo: instance homes at ${shortPath(root)})`); }
-  }
+  const root = ensureRoot(dirFlag());
   const retiringHome = homeFlag || findInstanceHome(root, name);
   // K3: a GUI-driven Remove carries the plan revision it showed and an
   // idempotency key. The revision is revalidated against a fresh plan
@@ -2765,7 +1780,7 @@ function retireCmd() {
     const replay = (dir) => { const p = join(dir, `.oats-retire-receipt.${idemKey}.json`); if (!existsSync(p)) return false; try { const prior = JSON.parse(readFileSync(p, "utf8")); if (prior.retired !== name) return false; if (args.includes("--json")) jsonOk({ ...prior, replayed: true }); else console.log(`retire ${name}: replayed receipt for key ${idemKey}`); return true; } catch { return false; } };
     for (const a of listAgents(root)) if (replay(join(a._dir, "instances"))) return;
     let fresh;
-    try { fresh = planRetire(dirFlag(), root, name, { home: homeFlag }); } catch (e) { return args.includes("--json") ? jsonFail(e.code || "E_LIFECYCLE_FAILED", e.message) : die(e.message); }
+    try { fresh = planRetire(dirFlag(), root, name, { home: homeFlag }); } catch (e) { return args.includes("--json") ? jsonFail(e.code || "E_LIFECYCLE_FAILED", e.message, e.details) : die(e.message); }
     replayPath = join(dirname(fresh.home), `.oats-retire-receipt.${idemKey}.json`);
     if (fresh.planRevision !== planRev) return args.includes("--json") ? jsonFail("E_PLAN_STALE", `the retire plan changed since it was shown (${planRev} → ${fresh.planRevision}); review the fresh plan`, { plan: fresh }) : die(`the retire plan changed since it was shown; re-run oats retire ${name} --plan`);
     // The plan promised: recorded children are STOPPED first (bounded, never
@@ -2780,7 +1795,9 @@ function retireCmd() {
     if (running.length) return args.includes("--json") ? jsonFail("E_CHILDREN_RUNNING", `${running.map((k) => k.instance).join(", ")} ${running.length === 1 ? "is" : "are"} still running after a bounded stop; nothing was retired and nothing was escalated`, { childrenStopped, plan: fresh }) : die(`children still running: ${running.map((k) => k.instance).join(", ")}; nothing retired`);
     expectedBranch = fresh.facts.work.observed ? fresh.facts.work.branch : undefined;
   }
-  const r = retireInstance(root, name, { home: homeFlag, self: isSelf, deleteBranch: args.includes("--delete-branch"), discardWorktree: args.includes("--discard-worktree"), keepDir: args.includes("--keep-dir"), force: args.includes("--force"), ...(expectedBranch !== undefined ? { expectedBranch } : {}) });
+  let r;
+  try { r = retireInstance(root, name, { home: homeFlag, self: isSelf, deleteBranch: args.includes("--delete-branch"), discardWorktree: args.includes("--discard-worktree"), keepDir: args.includes("--keep-dir"), force: args.includes("--force"), ...(expectedBranch !== undefined ? { expectedBranch } : {}) }); }
+  catch (e) { if (!e?.code) throw e; return args.includes("--json") ? jsonFail(e.code, e.message, e.candidates ? { ...e.details, candidates: e.candidates } : e.details) : die(e.message); }
   if (childrenStopped) r.childrenStopped = childrenStopped;
   if (replayPath) { r.planRevision = planRev; r.idempotencyKey = idemKey; r.replayed = false; try { writeFileAtomic(replayPath, JSON.stringify(r, null, 2)); } catch { /* receipt is evidence, not authority */ } }
   // A retired home's wake jobs are forgotten (definitions only; nothing is
@@ -2818,8 +1835,10 @@ function retireCmd() {
   // which is most of the harm of deleting it. Name the classes and the path.
   for (const recovery of r.workRecoveries || (r.workRecovery ? [r.workRecovery] : [])) {
     console.log(`Work that was not committed has been preserved: ${recovery.classes.join(", ")}`);
-    console.log(`  ${recovery.path}`);
+    console.log(`  ${recovery.path}${typeof recovery.bytes === "number" ? ` (${formatBytes(recovery.bytes)})` : ""}`);
+    for (const line of preservedOutputLines(recovery)) console.log(line);
   }
+  for (const w of r.warnings || []) console.log(`  WARNING: ${w}`);
   if (isSelf) console.log("This window dies in ~8s — say any goodbyes now.");
 }
 
@@ -2829,9 +1848,11 @@ function retireCmd() {
 function scheduleCmd() {
   const sub = args[1];
   const id = args[2] && !args[2].startsWith("--") ? args[2] : undefined;
-  // One schedule-owning scope for a directory: the team workspace (the
-  // config level declaring the team), else the outermost config level.
-  const ws = scheduleScopeOf(dirFlag());
+  // One schedule-owning scope for a directory: its deployment (the directory
+  // holding oats-local.yaml), resolved when a subcommand needs it — inside the
+  // try, so no deployment in reach is a typed refusal (E_LOCAL_MISSING).
+  let scope;
+  const ws = () => (scope ??= scheduleScopeOf(dirFlag()));
   const io = { hostStatus: () => hostUnitStatus() };
   const out = (result) => { if (JSON_MODE) jsonOk(result); else console.log(JSON.stringify(result, null, 2)); };
   const readSpec = () => {
@@ -2845,41 +1866,41 @@ function scheduleCmd() {
   const needId = () => { if (!id) throw scheduleError("E_BAD_ARGS", `oats schedule ${sub} <id>`); return id; };
   try {
     switch (sub) {
-      case "list": return out(listSchedules(ws, io));
-      case "show": return out({ schedule: describeSchedule(ws, needId(), io) });
-      case "add": { const spec = readSpec(); if (id && spec.id === undefined) spec.id = id; if (id && spec.id !== id) throw scheduleError("E_SCHEDULE_INVALID", `id ${JSON.stringify(spec.id)} in the file does not match ${JSON.stringify(id)}`, { field: "id" }); return out({ schedule: addSchedule(ws, spec, io) }); }
-      case "update": return out({ schedule: updateSchedule(ws, needId(), readSpec(), io) });
-      case "enable": return out({ schedule: setScheduleEnabled(ws, needId(), true, io) });
-      case "disable": return out({ schedule: setScheduleEnabled(ws, needId(), false, io) });
-      case "run": return out(runScheduleNow(ws, needId(), { io, force: args.includes("--force") }));
-      case "remove": return out(removeSchedule(ws, needId(), { force: args.includes("--force") }));
-      case "reconcile": return out(reconcileSchedule(ws, needId(), { io, clear: args.includes("--clear") }));
+      case "list": return out(listSchedules(ws(), io));
+      case "show": return out({ schedule: describeSchedule(ws(), needId(), io) });
+      case "add": { const spec = readSpec(); if (id && spec.id === undefined) spec.id = id; if (id && spec.id !== id) throw scheduleError("E_SCHEDULE_INVALID", `id ${JSON.stringify(spec.id)} in the file does not match ${JSON.stringify(id)}`, { field: "id" }); return out({ schedule: addSchedule(ws(), spec, io) }); }
+      case "update": return out({ schedule: updateSchedule(ws(), needId(), readSpec(), io) });
+      case "enable": return out({ schedule: setScheduleEnabled(ws(), needId(), true, io) });
+      case "disable": return out({ schedule: setScheduleEnabled(ws(), needId(), false, io) });
+      case "run": return out(runScheduleNow(ws(), needId(), { io, force: args.includes("--force") }));
+      case "remove": return out(removeSchedule(ws(), needId(), { force: args.includes("--force") }));
+      case "reconcile": return out(reconcileSchedule(ws(), needId(), { io, clear: args.includes("--clear") }));
       case "tick": {
         const dryRun = args.includes("--dry-run");
         if (args.includes("--host")) return out(tickHost({ io, dryRun }));
         const reg = readRegistry();
-        const considered = withHostLock(() => tickWorkspace(ws, { io, reg, wsList: reg.workspaces.includes(ws) ? reg.workspaces : [...reg.workspaces, ws], dryRun }));
-        return out({ tickedAt: new Date().toISOString(), considered, scheduler: schedulerStatus(ws, io) });
+        const considered = withHostLock(() => tickWorkspace(ws(), { io, reg, wsList: reg.workspaces.includes(ws()) ? reg.workspaces : [...reg.workspaces, ws()], dryRun }));
+        return out({ tickedAt: new Date().toISOString(), considered, scheduler: schedulerStatus(ws(), io) });
       }
       case "host": {
         const op = args[2];
-        if (op === "install") { registerWorkspace(ws); installHostUnit(); return out({ scheduler: schedulerStatus(ws, io) }); }
-        if (op === "uninstall") { unregisterWorkspace(ws); if (!readRegistry().workspaces.length) uninstallHostUnit(); return out({ scheduler: schedulerStatus(ws, io) }); }
-        if (op === "status") return out({ scheduler: schedulerStatus(ws, io) });
+        if (op === "install") { registerWorkspace(ws()); installHostUnit(); return out({ scheduler: schedulerStatus(ws(), io) }); }
+        if (op === "uninstall") { unregisterWorkspace(ws()); if (!readRegistry().workspaces.length) uninstallHostUnit(); return out({ scheduler: schedulerStatus(ws(), io) }); }
+        if (op === "status") return out({ scheduler: schedulerStatus(ws(), io) });
         throw scheduleError("E_BAD_ARGS", "oats schedule host install|uninstall|status");
       }
       default: throw scheduleError("E_BAD_ARGS", "usage: oats schedule list|show <id>|add <id> --file <spec.json>|update <id> --file <spec.json>|enable <id>|disable <id>|run <id> [--force]|remove <id> [--force]|reconcile <id> [--clear]|tick [--dry-run] [--host]|host install|uninstall|status [--dir <workspace>|--server <id>] [--json]");
     }
   } catch (e) {
     // K8b: typed refusal details travel (identity mismatch: key/declared; a refused file: its integrity source).
-    const details = Object.fromEntries(["key", "declared", "source", "field"].filter((k) => e[k] !== undefined).map((k) => [k, e[k]]));
+    const details = { ...(e.details && typeof e.details === "object" ? e.details : {}), ...Object.fromEntries(["key", "declared", "source", "field"].filter((k) => e[k] !== undefined).map((k) => [k, e[k]])) };
     if (JSON_MODE) jsonFail(e.code || "E_SCHEDULE_FAILED", e.message, Object.keys(details).length ? details : undefined); else die(e.message);
   }
 }
 
 async function sessionCmd() {
   try {
-    if (flag("native-record") !== undefined) throw Object.assign(new Error("--native-record outcome inspection requires exact captured deployment/resolution selectors"), { code: "E_BAD_ARGS" });
+    if (flag("native-record") !== undefined) throw Object.assign(new Error("--native-record outcome inspection is gone (the captured/portable path was removed in 0.26)"), { code: "E_BAD_ARGS" });
     const home = flag("home");
     let result;
     if (args[1] === "attach") {
@@ -2888,7 +1909,7 @@ async function sessionCmd() {
       return;
     }
     if (args[1] === "inspect") result = inspectInstanceSession(home);
-    else if (args[1] === "recompose") result = recomposeInstanceInstructions(home, { dryRun: args.includes("--dry-run") });
+    else if (args[1] === "recompose") throw Object.assign(new Error('unknown command "session recompose" — removed by the workspace model v2; use a re-spawn: an instance never changes under itself'), { code: "E_UNKNOWN_COMMAND" });
     else if (args[1] === "start" || args[1] === "restart") {
       const bad = (msg) => { throw Object.assign(new Error(msg), { code: "E_BAD_ARGS" }); };
       const model = flag("model");
@@ -2897,7 +1918,7 @@ async function sessionCmd() {
       if (launchConfig === true) bad("--launch-config needs a configuration name, or none");
       const runtime = flag("runtime");
       if (runtime === true || (runtime !== undefined && !LAUNCH_RUNTIMES.includes(runtime))) bad(`--runtime must be one of ${LAUNCH_RUNTIMES.join(", ")}`);
-      const opts = { model: model || undefined, launchConfig, runtime, yolo: yoloFlag(), env: process.env };
+      const opts = { model: model || undefined, launchConfig, runtime, yolo: yoloFlag(), env: process.env, ...(await homeLiveTeams(home)) };
       if (args[1] === "restart") {
         const grace = flag("stop-grace");
         if (grace !== undefined) { if (grace === true || !/^\d+$/.test(String(grace)) || Number(grace) < 1 || Number(grace) > 300) bad("--stop-grace needs a number of seconds (1..300) to wait for the harness after SIGTERM"); opts.stopGraceMs = Number(grace) * 1000; }
@@ -2922,7 +1943,7 @@ async function sessionCmd() {
       result = uploadAttachment({ file, home: home === true ? undefined : home });
     } else throw Object.assign(new Error("usage: oats session inspect|input|attach|start|restart|receive|upload --home /absolute/home [--text-file path] [--model id] [--launch-config name|none] [--runtime pi|claude|codex] [--yolo|--no-yolo] [--stop-grace seconds] [--name file] [--file path] [--json]"), { code: "E_BAD_ARGS" });
     if (JSON_MODE) jsonOk(result); else console.log(JSON.stringify(result, null, 2));
-  } catch (e) { cmdFail(e.code || "E_SESSION_FAILED", e.message); }
+  } catch (e) { cmdFail(e.code || "E_SESSION_FAILED", e.message, e.details); }
 }
 
 async function paneCmd() {
@@ -2935,8 +1956,7 @@ async function paneCmd() {
  * (docs/design/2026-09-23-simplified-workspace-model.md §4): writes
  * `<dir>/oats-local.yaml` naming the workspace, creates `<dir>/agents/` (the
  * instance homes), then runs exactly the `oats sync` path — discover over the
- * remotes, confirm membership, resolve `packages:`, approve (TTY) or list what
- * needs approval (exit 2), write `oats-lock.json`. Nothing is installed, no soul
+ * remotes, confirm membership, resolve `packages:`, write `oats-lock.json`. Nothing is installed, no soul
  * is created, nothing is spawned, no `oats-config.yaml` is written: the member
  * clones and the operator expert are the operator's next steps, printed here. */
 async function onboardCmd() {
@@ -3043,14 +2063,14 @@ async function onboardCmd() {
   const hostIsMember = members.some((m) => m.key === synced.discovery.key);
   const hosting = { host: synced.discovery.key, hostIsMember, rule: "If any member is private, host oats-workspace.yaml in a private repo that is not a public member (a dedicated <org>/workspace repo); public contributors then use the standalone case (from: here capabilities + oats.core)." };
   const result = { onboardApi: 2, standalone: standalone || undefined, local: localFile, dir, agents: join(dir, "agents"), lock: synced.lockFile, sync: synced.report, hosting, next: { clone: clones, spawn: spawnHint, souls: soulNames.slice(0, 3) } };
-  if (JSON_MODE) { jsonOk(result); process.exitCode = synced.approvalNeeded.length ? 2 : 0; return; }
+  if (JSON_MODE) { jsonOk(result); return; }
 
   console.log(`Onboarded ${shortPath(dir)} into workspace ${workspaceName(synced.discovery)} (${synced.discovery.key} @ ${short(synced.discovery.commit)}).${standalone ? `\n  (${standaloneNote(synced.discovery, { from: " from here" })})` : ""}\n`);
   printSyncReport(ctx, synced);
   console.log(`
 This directory (${shortPath(dir)}) is your deployment — any layout works; it now holds what the kernel needs:
   ├── oats-local.yaml     which workspace this machine realizes (+ host settings, disabled souls)
-  ├── oats-lock.json      exact commit + integrity + per-version executable approval per package
+  ├── oats-lock.json      exact commit + integrity per package
   └── agents/             instance homes, each self-contained
 Member clones live wherever you keep them (here, or anywhere named in oats-local.yaml clones:).
 
@@ -3060,9 +2080,8 @@ Next:
   2. Check who may read the host: ${synced.discovery.key}${hostIsMember ? " is itself a member" : " is a dedicated host"}. The workspace file
      names every member, so if any member is private the host must be a private repo that is not
      a public member; public contributors then get the standalone case (from: here + oats.core).
-  3. ${setupExpert ? "Spawn the operator expert to guide the rest (souls, teams, provider settings, approvals):" : "No soul named oats-operator-expert is listed here —"}
-       ${spawnHint ?? anySoulHint}${synced.approvalNeeded.length ? `\n  (first: \`oats sync --dir ${shortPath(dir)}\` in a terminal to approve ${synced.approvalNeeded.map((a) => `${a.id} ${a.version}`).join(", ")})` : ""}`);
-  process.exitCode = synced.approvalNeeded.length ? 2 : 0;
+  3. ${setupExpert ? "Spawn the operator expert to guide the rest (souls, teams, provider settings):" : "No soul named oats-operator-expert is listed here —"}
+       ${spawnHint ?? anySoulHint}`);
 }
 
 /** The clone URL of a member row: what the remote observed (from the workspace's members: refs;
@@ -3075,45 +2094,6 @@ function memberUrlOf(discovery, key) {
   return null;
 }
 
-function createCmd() {
-  const yolo = yoloFlag();
-  const name = args[1];
-  if (!name || name.startsWith("--")) die("usage: oats create <name> [--local] [--no-oats-core] [--description <d>] [--type <agent-type>] [--repo <r>] [--work worktree|checkout|attached|workspace|directory] [--runtime pi|claude|codex] [--model <m>] [--yolo|--no-yolo] [--instructions-file <f>]");
-  const local = args.includes("--local");
-  const startDir = dirFlag();
-  // `create` BOOTSTRAPS a deployment: with no agents/ or local-agents/ yet,
-  // anchor at the enclosing git repo (else the start dir). It is the command
-  // that populates the roster root, so it must not demand that the root
-  // already exist — that demand was the first thing a new user hit after
-  // `oats init` (a raw stack trace from ensureRoot). Local and committed souls
-  // anchor the same way; writeSoul creates the directories.
-  let root = findRoot(startDir);
-  // A configured package-only scope may resolve its future agents root before
-  // that directory exists. Preserve create's bootstrap receipt/message.
-  let bootstrapped = !!root && !existsSync(root) && !existsSync(join(dirname(root), "local-agents"));
-  if (!root) {
-    root = join(defaultRepo(startDir) || resolve(startDir), "agents");
-    bootstrapped = true;
-  }
-  const instrFile = flag("instructions-file");
-  const r = coreCreateAgent(root, {
-    name, local, oatsCore: !args.includes("--no-oats-core"), description: flag("description"), type: flag("type"), repo: flag("repo") || (flag("work") === "directory" ? undefined : defaultRepo(process.cwd())),
-    work: flag("work"), runtime: flag("runtime"), model: flag("model"), yolo,
-    instructions: instrFile ? readFileSync(instrFile, "utf8") : undefined,
-  });
-  // A declared oats.core is a requirement spawn will enforce: say the next
-  // step here, not only at the refusal.
-  const declared = r.declaredCapabilities || [];
-  const inactive = declared.filter((id) => !(resolveOatsConfig(workspaceOf(root), name).capabilities || []).some((c) => c.id === id));
-  const next = inactive.length ? [{ code: "next-step", message: `${name} declares ${inactive.join(", ")}; before spawning, pin their packages in oats-workspace.yaml packages: and declare them in soul.yaml capabilities: { <cap>: { from } } (workspace model v2)` }] : [];
-  const notes = [...(r.notes || []), ...next];
-  if (args.includes("--json")) { console.log(JSON.stringify({ ...r, ...(notes.length ? { notes } : {}), ...(bootstrapped ? { agentsRoot: root } : {}) }, null, 2)); return; }
-  for (const information of notes) console.error(`[${information.code}] ${information.message}`);
-  if (bootstrapped) console.log(`Created deployment root ${shortPath(root)} (this scope had no agents/ yet)`);
-  console.log(`Created ${r.kind === "local" ? "LOCAL agent (uncommitted — soul lives in local-agents/, gitignored)" : "agent"} "${r.agent}" — soul at ${shortPath(r.soul)}`);
-  console.log(`Edit ${shortPath(join(r.soul, "AGENTS.md"))} to define its role, then${inactive.length ? ` activate ${inactive.join(", ")} (above) and` : ":"} oats spawn ${r.agent} --task "..."`);
-}
-
 // ---------- capability command dispatch ----------
 /**
  * oats <namespace> <command> [args…] — run a command an active capability
@@ -3127,7 +2107,7 @@ function createCmd() {
  *     namespace's capability into <deployment>/.oats/modules/<cap>@<commit12>/
  *     and run THAT copy with the soul's merged payload (lib/operator-dispatch.mjs;
  *     contracts doc, "Post-0.25.0 clarifications");
- *   - otherwise the classic config chain.
+ *   - otherwise no namespace is active (the help fallthrough answers).
  */
 async function capabilityCommand() {
   // JSON-aware boundary: in --json mode every dispatch failure — inactive or
@@ -3159,64 +2139,79 @@ async function capabilityCommand() {
       throw e;
     }
     if (!hit) return NOT_DISPATCHED;
-    const teamCtx = hit.soul?.team ? { name: hit.soul.team } : undefined;
-    return runManifestCommand({ capability: hit.module.name, ...hit.manifest }, hit.settings, teamCtx, hit.ensureTree);
+    // The same team/workspace facts a spawn hook receives (lead decision c3-7).
+    const teamCtx = teamEnv(resolvedFromPrepared(hit.prepared, hit.deployment));
+    // No home, so no recorded soul: the soul's per-commit copy is OATS_SOUL when a spawn
+    // already fetched exactly this commit; otherwise the command gets none (never ambient).
+    const cachedSoul = hit.soul?.commit ? join(hit.deployment, "agents", hit.soul.name, "souls", String(hit.soul.commit).slice(0, 12)) : null;
+    return runManifestCommand({ capability: hit.module.name, ...hit.manifest }, hit.settings, teamCtx, hit.ensureTree, cachedSoul && existsSync(join(cachedSoul, "soul.yaml")) ? realpathSync(cachedSoul) : undefined);
   }
 
   async function dispatch() {
     let activeIds;
     let context = process.cwd();
-    let teamCtx;
-    const instanceHome = process.env.PI_AGENT_HOME || process.env.OATS_HOME;
+    let teamCtx, homeMeta, homeTeamCtx;
+    // OATS_INSTANCE_HOME is the canonical identity; the older names still count.
+    const instanceHome = process.env.OATS_INSTANCE_HOME || process.env.PI_AGENT_HOME || process.env.OATS_HOME;
     const metaFile = instanceHome && join(instanceHome, "instance.json");
     // Capability-id keyed — never answer for `constructor`/`toString`. Belt and
     // braces: the ids come from instance.json, which spawn wrote from resolved
     // manifests. Null-prototype because the dispatcher indexes it with the
     // namespace the operator typed on the command line.
     let capSettings = Object.create(null);
-    let instanceModules = false;
     let deployment = null;
+    let soulDir;
     try {
       if (metaFile && existsSync(metaFile)) {
         const meta = JSON.parse(readFileSync(metaFile, "utf8"));
-        instanceModules = !!(meta.modules && typeof meta.modules === "object");
         activeIds = (meta.capabilities || []).map((c) => c.id);
         for (const c of meta.capabilities || []) capSettings[c.id] = c.settings || {};
+        // Workspace-model homes only (lead decision c3 Q2).
+        if (isCapturedHome(meta)) { const e = capturedHomeRefusal(instanceHome, "nothing was dispatched"); bail(e.code, e.message, e.details); }
+        if (!isWorkspaceHome(meta)) { const e = preWorkspaceHome(instanceHome, "nothing was dispatched"); bail(e.code, e.message); }
         context = meta.repo || context;
-        // Team: the spawn-time snapshot, but fall back to live config — instances
-        // spawned before a team: block was declared have no snapshot.
-        teamCtx = meta.team || resolveOatsConfig(context).team;
+        soulDir = instanceSoulDir(instanceHome, meta);
+        // The team/workspace facts the home recorded at spawn, as its hooks got them, with the
+        // recorded eligible teams (OATS_TEAMS_SOURCE=recorded). Only the home's MESSAGING module
+        // gets them live (below): its team verbs (join/leave/teams) must see what the workspace
+        // allows now, and no other command pays a remote read for them.
+        const ws = meta.workspace && typeof meta.workspace === "object" ? meta.workspace : {};
+        const messaging = (meta.capabilities || []).find((c) => c.layer === "messaging")?.id;
+        homeMeta = { meta, messaging };
+        homeTeamCtx = (teams, teamsSource) => teamEnv({ workspace: { key: ws.key, name: ws.name, deployment: ws.deployment, team: ws.soul?.team, slots: { messaging } }, payloads: meta.providers, teams, teamsSource });
+        teamCtx = homeTeamCtx(meta.teams, "recorded");
       } else {
         // Not inside a home: a v2 deployment (oats-local.yaml in reach) resolves
         // through the workspace, exactly as a spawn of --soul would (below).
         try { const { deploymentOf } = await import("../lib/operator-dispatch.mjs"); deployment = deploymentOf(context); }
         catch (e) { if (typeof e?.code === "string" && e.code.startsWith("E_")) bail(e.code, e.message, e.details); throw e; }
-        if (!deployment) {
-          const resolved = resolveOatsConfig(context, flag("soul"));
-          activeIds = resolved.capabilities.map((c) => c.id);
-          for (const c of resolved.capabilities) capSettings[c.id] = c.settings || {};
-          teamCtx = resolved.team;
-        }
+        // No home and no deployment in reach: no capability namespace is active.
+        if (!deployment) return NOT_DISPATCHED;
       }
     } catch (e) { bail("E_CONFIG_BROKEN", e.message || e); throw e; }
     if (deployment) return operatorDispatch();
     // Workspace model: an instance's own materialized modules are the command
     // namespaces available to it (instance.json.modules → <home>/.oats/modules).
-    const mans = Object.values(capabilityManifests(instanceModules ? instanceHome : context)).filter((m) => m.command === cmd && m.commands);
+    const mans = Object.values(capabilityManifests(instanceHome)).filter((m) => m.command === cmd && m.commands);
     if (!mans.length) return NOT_DISPATCHED;
     if (mans.length > 1) bail("E_DUPLICATE_NAMESPACE", `duplicate operational command namespace "${cmd}": ${mans.map((m) => m.capability).join(", ")}`);
     const m = mans[0];
     if (!activeIds.includes(m.capability)) bail("E_CAPABILITY_INACTIVE", `${m.capability} command namespace is not active in the current context/instance`);
-    const trust = capabilityTrust(m, context);
+    const trust = capabilityTrust(m);
     if (!trust.trusted) bail("E_CAPABILITY_BLOCKED", `${m.capability} executable command is blocked: ${trust.reason}`);
-    return runManifestCommand(m, capSettings[m.capability] || {}, teamCtx, () => m._dir);
+    if (homeMeta && m.capability === homeMeta.messaging) {
+      const { liveTeams } = await import("../lib/instance-resolution.mjs");
+      const live = await liveTeams(instanceHome, homeMeta.meta, { remoteOptions: remoteOptionsFromEnv() });
+      teamCtx = homeTeamCtx(live.teams, live.source);
+    }
+    return runManifestCommand(m, capSettings[m.capability] || {}, teamCtx, () => m._dir, soulDir);
   }
 
   /** Help / unknown-command / spec validation / exec — shared by every context.
    *  `m` is the manifest (with `capability`; `_dir` may be absent until `ensureDir`
    *  resolves the directory holding the executable — the operator branch fetches
    *  the module tree only when a command is actually going to run). */
-  async function runManifestCommand(m, settings, teamCtx, ensureDir) {
+  async function runManifestCommand(m, settings, teamCtx, ensureDir, soulDir) {
     const sub = args[1];
     const cmds = Object.keys(m.commands);
     // `oats <ns> --help` and `oats <ns> <cmd> --help` answer from the manifest
@@ -3250,8 +2245,11 @@ async function capabilityCommand() {
     try { abs = capabilityExecutablePath(withDir, script); }
     catch (e) { bail("E_CAPABILITY_BROKEN", e.message); }
     if (!abs) bail("E_CAPABILITY_BROKEN", `${cmd} ${sub}: script not found (${join(dir, script)})`);
+    // OATS_SOUL is the recorded soul or nothing: an ambient value inherited from the
+    // invoking process names some other soul (a coordinator's own), never this one.
+    const { OATS_SOUL: _ambientSoul, ...inherited } = process.env;
     const r = spawnSync("node", [abs, ...rest, ...args.slice(2)], { stdio: "inherit", env: {
-      ...process.env, OATS_CAPABILITY: m.capability,
+      ...inherited, OATS_CAPABILITY: m.capability,
       // Package-runtime boundary: dispatched commands receive the active
       // capability's EFFECTIVE settings (instance snapshot, resolved context, or
       // the soul's merged payload on operator-level dispatch), same contract as
@@ -3262,7 +2260,10 @@ async function capabilityCommand() {
       // canonical absolute executable of THIS CLI; official consumers execFile
       // it directly and never resolve `oats` from PATH or a shell.
       OATS_CLI_BIN: CLI_BIN,
-      OATS_TEAM_NAME: teamCtx?.name || "", OATS_TEAM_ID: teamCtx?.id || "", OATS_TEAM_SCOPE: teamCtx?.scope || "",
+      ...teamEnv(null), ...(teamCtx || {}),
+      // The soul the command acts for (an instance home's recorded soul directory):
+      // homes carry no soul link, so providers read it here.
+      ...(soulDir ? { OATS_SOUL: soulDir } : {}),
     } });
     // Child never ran (spawn error): nothing reached stdout — keep the envelope contract.
     if (r.error) bail("E_CAPABILITY_BROKEN", `oats ${cmd} ${sub}: ${r.error.message || r.error}`);
@@ -3270,52 +2271,6 @@ async function capabilityCommand() {
   }
 }
 
-// ---------- agent types ----------
-function typeCmd() {
-  const sub = args[1];
-  const dir = dirFlag();
-  const file = join(dir, "oats-config.yaml");
-  if (sub === "list") {
-    const seen = new Map();
-    for (const cfg of configChain(dir)) for (const [name, spec] of Object.entries(cfg["agent-types"] || {})) if (!seen.has(name)) seen.set(name, { desc: spec?.description, level: cfg._level });
-    if (!seen.size) { console.log("No agent types declared in the config chain."); return; }
-    for (const [name, { desc, level }] of seen) console.log(`${name}  ${desc ? `— ${desc}  ` : ""}[${shortPath(level)}]`);
-    return;
-  }
-  if (sub !== "add" || !args[2] || args[2].startsWith("--")) die("usage: oats type add <name> [--description <d>] [--dir <dir>] | oats type list [--dir <dir>]");
-  const name = args[2];
-  if (!/^[a-z][a-z0-9-]*$/.test(name)) die(`agent type "${name}" must be lowercase alphanumeric/hyphens`);
-  const description = flag("description");
-  let text = existsSync(file) ? readFileSync(file, "utf8") : `name: ${scaffoldConfigName(dir)}\n`;
-  const cfg = existsSync(file) ? withConfigFile(file, () => parseYamlNested(text)) : {};
-  // Own-property: `constructor` is a legal agent-type name, and a plain lookup
-  // would report it as already declared in a config that never mentions it.
-  const declaredTypes = cfg["agent-types"];
-  if (declaredTypes && typeof declaredTypes === "object" && Object.hasOwn(declaredTypes, name)) die(`agent type "${name}" already declared in ${shortPath(file)}`);
-  // The NAME is already held to a strict grammar above; the DESCRIPTION was
-  // written verbatim onto its own line, so it could inject document the same
-  // way a `--settings` value could.
-  const block = [`  ${name}:`, ...(description ? [`    description: ${assertSafeConfigValue(description, "--description")}`] : [])];
-  const lines = text.replace(/\n*$/, "\n").split("\n");
-  // Drop the scaffold comment block once a real agent-types block exists.
-  const scaffold = lines.findIndex((l) => /^# ── Agent types/.test(l));
-  if (scaffold >= 0) {
-    let e = scaffold;
-    while (e < lines.length && (/^#/.test(lines[e]) || lines[e] === "")) { if (lines[e] === "" && !/^#/.test(lines[e + 1] || "x")) break; e++; }
-    lines.splice(scaffold, e - scaffold);
-  }
-  const start = lines.findIndex((l) => /^agent-types:\s*(#.*)?$/.test(l));
-  if (start >= 0) {
-    let end = start + 1;
-    while (end < lines.length && (/^\s/.test(lines[end]) || lines[end] === "")) { if (lines[end] === "" && !/^\s/.test(lines[end + 1] || "x")) break; end++; }
-    lines.splice(end, 0, ...block);
-  } else {
-    lines.splice(1, 0, "", "agent-types:", ...block);
-  }
-  writeFileSync(file, lines.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n*$/, "\n"));
-  console.log(`Declared agent type "${name}" at ${levelOf(dir)} level (${shortPath(file)})`);
-  console.log(`Souls join it with: oats create <agent> --type ${name} (or type: ${name} in soul.yaml)`);
-}
 
 // ---------- update ----------
 function updateCmd() {
@@ -3370,7 +2325,7 @@ function versionCmd() {
     // Phase B: `instance-modules` and `spawn-provider-payload` are advertised only once spawn
     // runs on resolve/materialize (contract §6); a feature the binary does not implement is
     // never listed.
-    console.log(JSON.stringify({ schemaVersion: 1, name: "@awebai/oats", version: OATS_VERSION, desktopApi: 1, runtimes: ["pi", "claude", "codex"], sessionBackends: ["tmux", "herdr"], launchOptions: ["yolo"], remote: ["spawn", "retire", "status", "session", "session-start", "session-restart", "launch-config", "roster", "harvest", "schedule", "session-upload", "operations"], features: ["retire-home", "session-start", "session-restart", "launch-config", "schedule", "session-upload", "operations", "instance-git", "instance-git-remote", "souls-declarations", "lifecycle-plans", "retire-retention", "readiness", "spawn-preview", "instance-events", "instance-events-2", "schedule-history", "schedule-read-2", "session-recompose", "readiness-verify", "spawn-preview-2", "spawn-idempotency", "spawn-idempotency-2", "spawn-apply-2", "workspace-v2", "instance-modules", "spawn-provider-payload", "served-identity"], workspaceApi: 2, instanceGitApi: 1, spawnApplyApi: 1, soulsApi: 1, lifecycleApi: 1, readinessApi: 1, spawnPreviewApi: 2, eventsApi: 2, scheduleHistoryApi: 3, scheduleApi: SCHEDULE_API, operationsApi: 1, capturedDispatchApi: 1, capturedDispatchActions: ["inspect", "compose", "command", "operation", "spawn", "trust"] }));
+    console.log(JSON.stringify({ schemaVersion: 1, name: "@awebai/oats", version: OATS_VERSION, desktopApi: 1, runtimes: ["pi", "claude", "codex"], sessionBackends: ["tmux", "herdr"], launchOptions: ["yolo"], remote: ["spawn", "retire", "status", "session", "session-start", "session-restart", "launch-config", "roster", "harvest", "schedule", "session-upload", "operations"], features: ["retire-home", "session-start", "session-restart", "launch-config", "schedule", "session-upload", "operations", "instance-git", "instance-git-remote", "souls-declarations", "lifecycle-plans", "retire-retention", "readiness", "spawn-preview", "instance-events", "instance-events-2", "schedule-history", "schedule-read-2", "spawn-preview-2", "spawn-idempotency", "spawn-idempotency-2", "spawn-apply-2", "workspace-v2", "instance-modules", "spawn-provider-payload", "served-identity", "packages-no-approval", "spawn-name", "settings-origins", "teams", "settings-declared", "capabilities-private", "layers-from"], workspaceApi: 2, instanceGitApi: 1, spawnApplyApi: 1, soulsApi: 2, lifecycleApi: 1, readinessApi: 2, spawnPreviewApi: 2, eventsApi: 2, scheduleHistoryApi: 3, scheduleApi: SCHEDULE_API, operationsApi: 2 }));
     return;
   }
   console.log(`@awebai/oats ${OATS_VERSION} (desktop API v1)`);
@@ -3508,7 +2463,7 @@ async function serverRouteCmd() {
   // The operations contract addresses an exact member context on the host,
   // so its explicit --dir travels; every other routed command takes its
   // scope from the registration.
-  const explicitScopeOk = ["inspect", "operation", "soul", "launch-config"].includes(cmd);
+  const explicitScopeOk = ["inspect", "operation", "launch-config"].includes(cmd);
   if (!explicitScopeOk && (flag("dir") !== undefined || args.some((a) => a.startsWith("--dir=")))) bail("E_BAD_ARGS", "--dir cannot be combined with --server: the remote workspace comes from the server registration");
   if (cmd === "launch-config") {
     const action = args[1];
@@ -3635,7 +2590,6 @@ async function serverRouteCmd() {
   // local --task-file is read here and travels as --task text, since the
   // remote cannot read this machine's files.
   const rest = [];
-  let routedInput;
   for (let i = 1; i < args.length; i++) {
     const a = args[i];
     if (a === "--server") { i++; continue; }
@@ -3665,23 +2619,10 @@ async function serverRouteCmd() {
       rest.push("--wake-message", readFileSync(f, "utf8"));
       continue;
     }
-    // Soul instructions travel as BYTES on the ssh stdin (the same transport
-    // as session upload), never as a path the host cannot read nor as a
-    // command-line argument.
-    if (a === "--instructions-file") {
-      const f = args[++i];
-      if (!f || f.startsWith("--")) bail("E_BAD_ARGS", "--instructions-file needs a path");
-      let bytes; try { bytes = readFileSync(f); } catch (e) { bail("E_BAD_ARGS", `instructions file not readable: ${f}: ${e.message}`); }
-      if (bytes.includes(0)) bail("E_BAD_ARGS", "--instructions-file must be text without NUL bytes");
-      if (bytes.length > INSPECT_TEXT_CAP) bail("E_BAD_ARGS", `--instructions-file is ${bytes.length} bytes; the bound is ${INSPECT_TEXT_CAP}`);
-      routedInput = bytes;
-      rest.push("--instructions-stdin");
-      continue;
-    }
     rest.push(a);
   }
   let routed;
-  try { routed = routeCommand(id, cmd, rest, routedInput === undefined ? {} : { input: routedInput }); }
+  try { routed = routeCommand(id, cmd, rest); }
   catch (e) { bail(e.code || "E_SSH", e.message); }
   const { envelope, stderr } = routed;
   if (stderr && stderr.trim()) process.stderr.write(stderr.endsWith("\n") ? stderr : stderr + "\n");
@@ -3706,7 +2647,8 @@ async function serverRouteCmd() {
     console.log(`Retired ${r.retired} on ${id}${r.deferred ? " (deferred completion scheduled there)" : ""}${r.rollbackIncomplete ? " — cleanup INCOMPLETE on the server, home retained there" : ""}`);
     for (const recovery of r.workRecoveries || (r.workRecovery ? [r.workRecovery] : [])) {
       console.log(`Work that was not committed has been preserved on ${target.sshHost}: ${(recovery.classes || []).join(", ")}`);
-      console.log(`  ${recovery.path}`);
+      console.log(`  ${recovery.path}${typeof recovery.bytes === "number" ? ` (${formatBytes(recovery.bytes)})` : ""}`);
+      for (const line of preservedOutputLines(recovery)) console.log(line);
     }
     if (r.rollbackIncomplete) { for (const f of r.rollbackIncomplete) console.error(`  ${f}`); console.error(`Fix the cause there and re-run \`oats retire ${r.retired} --server ${id}\`.`); process.exit(1); }
   } else {
@@ -3735,70 +2677,44 @@ async function serverRouteCmd() {
 // blame` pointing at the commit that last changed each command.
 const TYPED_CLI_FAILURES = new Set(["unsafe-config-key", "unsafe-config-value"]);
 /** Removed 0.24 verbs → their v2 replacement (workspace model v2, decision 5). Checked before capability dispatch. */
-const REMOVED_VERBS = { install: "oats sync", restore: "oats sync", init: "oats-local.yaml + oats sync", use: "soul.yaml capabilities: { <cap>: { from } } + workspace defaults", trust: "oats sync (approval is asked once per package version)", list: "oats workspace status | oats capabilities", catalog: "oats package add <id> <version> (bare versions resolve through package-catalog.json)", remove: "oats package remove <id>", migrate: "a rebuild (no migration: docs/design/2026-09-23-workspace-module-contracts.md)", config: "oats-local.yaml (host settings) and oats-workspace.yaml (shared)", inject: "injection overrides are not part of the workspace model yet; edit the capability inject in its member repo" };
+const REMOVED_VERBS = { prepare: "`oats onboard` / `oats sync` to set up a workspace, and `oats spawn <soul> --preview` to see what a spawn would resolve (the captured/portable path was removed in 0.26)", create: "author souls/<name>/soul.yaml + AGENTS.md in a member repository, then `oats sync`", type: "the soul's own soul.yaml in its member repository (agent types were a classic config block)", soul: "the soul's soul.yaml / AGENTS.md in its member repository, then `oats sync` (per-spawn choices: spawn flags or a launch configuration)", install: "oats sync", restore: "oats sync", init: "oats-local.yaml + oats sync", use: "soul.yaml capabilities: { <cap>: { from } } + workspace defaults", trust: "declaring the package in packages: (package approval was removed; oats sync locks commit + integrity)", list: "oats workspace status | oats capabilities", catalog: "oats package add <id> <version> (bare versions resolve through package-catalog.json)", remove: "oats package remove <id>", migrate: "a rebuild (no migration: docs/design/2026-09-23-workspace-module-contracts.md)", config: "oats-local.yaml (host settings) and oats-workspace.yaml (shared)", inject: "injection overrides are not part of the workspace model yet; edit the capability inject in its member repo" };
 try {
-// Inspect explicit selectors with the existing parser before new-work routing,
-// including selectors before the command. Inherited captures are not prepare inputs.
-let captured;
-try { captured = capturedSelector(args, {}); }
-catch (error) {
-  if (JSON_MODE) jsonFail(error.code || "E_BAD_ARGS", error.message);
-  die(error.message);
-}
-const sourceInspection = (cmd === "inspect" || captured?.args[0] === "inspect")
-  && args.some(arg => arg === "--request" || arg.startsWith("--request="));
-if (sourceInspection) {
-  if (captured) {
-    if (JSON_MODE) jsonFail("E_BAD_ARGS", "source inspection is explicit new work and cannot use captured selectors");
-    die("source inspection is explicit new work and cannot use captured selectors");
-  }
-  if (args.includes("--help") || args.includes("-h")) { if (JSON_MODE) jsonOk({ command: cmd, usage: usageLinesFor(cmd) }); else usageFor(cmd); process.exit(0); }
-  inspectOnboardingCmd(); process.exit(0);
-}
-if (cmd === "prepare" || captured?.args[0] === "prepare") {
-  if (captured) {
-    if (JSON_MODE) jsonFail("E_BAD_ARGS", "prepare is explicit new work and cannot use captured selectors");
-    die("prepare is explicit new work and cannot use captured selectors");
-  }
-  if (args.includes("--help") || args.includes("-h")) { if (JSON_MODE) jsonOk({ command: cmd, usage: usageLinesFor(cmd) }); else usageFor(cmd); process.exit(0); }
-  prepareCmd(); process.exit(0);
-}
-if (cmd === "onboard" || captured?.args[0] === "onboard") {
-  if (captured) {
-    if (JSON_MODE) jsonFail("E_BAD_ARGS", "onboard is explicit workspace bootstrap and cannot use captured selectors");
-    die("onboard is explicit workspace bootstrap and cannot use captured selectors");
-  }
+// The captured/portable path was removed in 0.26 (lead decisions on (e), D2/D3):
+// its selectors and an inherited captured context are refused, never quietly
+// resolved against the current context instead. `version` answers regardless:
+// host protocol negotiation describes this executable.
+{
+  const end = args.indexOf("--"), head = end < 0 ? args : args.slice(0, end);
+  const selector = head.find((a) => /^--(deployment|resolution|artifact-set)(=|$)/.test(a));
+  const refuse = (message, details) => { if (JSON_MODE) jsonFail("E_UNSUPPORTED_MODE", message, details); die(message); };
+  if (selector) refuse(`${selector.split("=")[0]}: a captured selector is refused (the captured/portable path was removed in 0.26); run the command in its workspace deployment or instance home instead`, { selector: selector.split("=")[0] });
+  const inherited = ["OATS_RESOLUTION", "OATS_DEPLOYMENT"].filter((k) => process.env[k]);
+  if (inherited.length && cmd !== "version") refuse(`this environment carries a captured context (${inherited.join(", ")}): the captured/portable path was removed in 0.26, and nothing is run against the current context in its place — retire the captured home and re-spawn it from the deployment`, { inherited });
+  if (cmd === "inspect" && head.some((a) => a === "--request" || a.startsWith("--request="))) {
+    const message = "oats inspect --request (portable onboarding inspection) is gone (the captured/portable path was removed in 0.26); use `oats onboard` / `oats sync` to set up a workspace and `oats spawn <soul> --preview` to see what a spawn would resolve";
+    if (JSON_MODE) jsonFail("E_UNKNOWN_COMMAND", message, { removed: "inspect --request", replacement: "oats onboard / oats sync; oats spawn --preview" });
+    die(message);
+  }
+}
+if (cmd === "onboard") {
   if (args.includes("--help") || args.includes("-h")) { if (JSON_MODE) jsonOk({ command: cmd, usage: usageLinesFor(cmd) }); else usageFor(cmd); process.exit(0); }
   await onboardCmd();
 }
 else {
-// Other commands retain their existing explicit/inherited selection rules.
-try { captured ??= capturedSelector(args); }
-catch (error) {
-  if (JSON_MODE) jsonFail(error.code || "E_BAD_ARGS", error.message);
-  die(error.message);
-}
-if (captured) {
-  args.splice(0, args.length, ...captured.args); cmd = args[0];
-  // Host protocol negotiation describes this executable, not a mutable
-  // configuration. An inherited capture must not break `oats version` probes.
-  if (captured.explicit || cmd !== "version") { capturedCommand(captured); process.exit(0); }
-}
 // `--help`/`-h` anywhere after a kernel command prints that command's usage
 // and exits 0 BEFORE any dispatch: a fresh operator inspects --help before
 // using a command, and `install --help` once ran the bare restore while
 // `okf harvest --help` spawned a harvester (BeadHub, 2026-09-05).
 const wantsHelp = args.slice(1).some((a) => a === "--help" || a === "-h");
 if (cmd && KERNEL_COMMANDS.has(cmd) && wantsHelp) { if (JSON_MODE) { jsonOk({ command: cmd, usage: usageLinesFor(cmd) }); process.exit(0); } usageFor(cmd); process.exit(0); }
-if (flag("server") !== undefined && ["spawn", "retire", "status", "session", "okf", "schedule", "inspect", "operation", "soul", "launch-config"].includes(cmd)) await serverRouteCmd();
+if (flag("server") !== undefined && ["spawn", "retire", "status", "session", "okf", "schedule", "inspect", "operation", "launch-config"].includes(cmd)) await serverRouteCmd();
 else if (cmd === "server") serverCmd();
-else if (cmd === "inspect") inspectCmd();
-else if (cmd === "operation") operationCmd();
-else if (cmd === "soul") await soulCmd();
+else if (cmd === "inspect") await inspectCmd();
+else if (cmd === "operation") await operationCmd();
 else if (cmd === "launch-config") await launchConfigCmd();
 else if (cmd === "doctor") {
   const doctorDir = args[1] && !args[1].startsWith("--") ? args[1] : undefined;
-  args.includes("--json") ? doctorJson(doctorDir) : doctor(doctorDir);
+  await (args.includes("--json") ? doctorJson(doctorDir) : doctor(doctorDir));
 }
 else if (cmd === "update") {
   // `oats update <package>` left with the installed tier (packages are pinned in
@@ -3807,8 +2723,7 @@ else if (cmd === "update") {
   if (t || flag("to") !== undefined) { cmdFail("E_BAD_ARGS", "oats update takes no package: pin package versions in oats-workspace.yaml (`oats package add <id> <version>`), then `oats sync`; bare `oats update [--check] [--yes]` updates the kernel"); process.exit(1); }
   updateCmd();
 }
-else if (cmd === "type") typeCmd();
-else if (cmd === "readiness") readinessCmd();
+else if (cmd === "readiness") await readinessCmd();
 else if (cmd === "instance") instanceCmd();
 else if (cmd === "root") console.log(resolve(new URL("..", import.meta.url).pathname));
 else if (cmd === "sync") await syncCmd();
@@ -3824,7 +2739,6 @@ else if (cmd === "session") await sessionCmd();
 else if (cmd === "schedule") scheduleCmd();
 else if (cmd === "spawn") { try { await spawnCmd(); } catch (e) { if (TYPED_CLI_FAILURES.has(e?.code)) throw e; if (JSON_MODE) jsonFail("E_SPAWN_FAILED", e.message || e); throw e; } }
 else if (cmd === "retire") retireCmd();
-else if (cmd === "create") createCmd();
 else if (cmd === "capture" || cmd === "recall" || cmd === "setup") await recordCmd(cmd);
 else if (cmd === "experimental") await experimentalCmd();
 // `!HELP_WORDS.has(cmd)`: usage NEVER depends on deployment state. `help` is a
@@ -3874,7 +2788,6 @@ Usage:
   oats version [--json]                      kernel version; --json emits the
                                             Desktop CLI API v1 probe payload
   oats status [--json]                       agents, souls, running instances
-  oats status --team [--json]                whole-team roster across the team scope's repos
   oats server add <id> --ssh <alias>         register another machine's OATS (OpenSSH alias,
       --workspace </abs/path> [--oats <p>]   remote workspace, remote oats path; no keys stored;
       [--path <dir:dir>]                    --path = dirs prepended to the remote PATH, e.g. ~/.local/bin)
@@ -3898,24 +2811,19 @@ Usage:
   oats session start --server <id>           start a stopped remote instance in its existing home
       --instance <name> | --home <abs>       over its saved route; the server must advertise
       [--model <m>] [--json]                 session-start (oats 0.22.9 or later)
-  oats inspect|operation|soul --server <id>   the same commands on a registered server over its
+  oats inspect|operation --server <id>        the same commands on a registered server over its
       ... [--dir <remote member>] [--home <abs>]  saved route (an explicit --dir travels as is; a --home
                                             is its own context; else the registered workspace);
-                                            soul set --instructions-file streams the bytes; the
-                                            server must advertise operations (oats 0.22.16 or later)
+                                            the server must advertise operations (oats 0.22.16 or later)
   oats session upload --server <id>          copy a local file into a remote instance's private
       --instance <name> | --home <abs>       attachments over its saved route (bytes stream on
       --file <path> [--json]                 ssh stdin; sha256 verified); the server must
                                             advertise session-upload (oats 0.22.13 or later)
   oats onboard [<dir>] --workspace <repo ref> realize a workspace here: writes <dir>/oats-local.yaml
-      [--json]                               and agents/, then runs the oats sync path (lock v3;
-                                            exit 2 while approvals are pending) and prints the
+      [--json]                               and agents/, then runs the oats sync path (lock v3)
+                                            and prints the
                                             next steps (clone members you work IN, spawn
                                             oats-operator-expert); creates no soul, spawns nothing
-  oats create <name> [--local] [--no-oats-core] create an agent soul; --local = full
-      [--description <d>] [--repo <r>]      soul under local-agents/ (uncommitted,
-      [--work <mode>] [--runtime pi|claude|codex] gitignored; same memory + lifecycle)
-      [--model <m>] [--yolo|--no-yolo] [--instructions-file <f>]
   oats session inspect|input|attach --home <absolute-home> [--text-file <path>] [--json]
   oats schedule list|show <id>|add <id> --file <spec.json>|update <id> --file <spec.json>
       enable|disable|run|remove|reconcile <id>   workspace-scoped, host-owned schedules (spawn,
@@ -3940,19 +2848,21 @@ Usage:
                                             spawn hooks); --model replaces the recorded model
                                             for this and later starts; a live harness is refused
   oats spawn <agent> [--task <text>]         spawn an instance (tmux/Herdr; --no-launch
-      [--purpose <slug>] [--repo <r>]       = scaffold only); --instructions-file/
-      [--parent <instance>]                 --def-file creates a local agent;
-      [--no-oats-core]                      omit the default only on NEW local souls;
+      [--purpose <slug>] [--repo <r>]       = scaffold only); the agent is a workspace
+      [--parent <instance>]                 soul or a capability-defined agent
       [--relation child|sibling|parent|unrelated]    --relation + --relative-to anchor the
       [--relative-to <instance>]            new instance to an existing one; --parent X
       [--relative-root <agents-root>]       disambiguates same-named team anchors
       [--work worktree|checkout|attached|workspace|directory]  = sugar for --relative-to X --relation
       [--work-dir <owner-work>] [--runtime pi|claude|codex] [--backend tmux|herdr] [--herdr-socket <path>] [--yolo|--no-yolo] [--model <m>] [--branch <b>]  child (default: unrelated, top-level)
-      [--instructions-file <f>|--def-file <f>] [--no-launch] [--json]
-                                            with team: declared, unknown local souls
+      [--no-launch] [--json]
+                                            with team: declared, unknown souls
                                             resolve across the team scope's repos
                                             directory: owned home/work, config context may
                                             be non-Git; rejects --work-dir and --branch
+      [--name <slug>]                        the exact instance name (no <agent>- prefix;
+                                            not with --purpose); must be a slug, not a
+                                            soul name, and unused in the deployment
   oats retire <instance> [--force]           retire an instance (window, hooks,
       [--self] [--delete-branch]            worktree, home); --self = retire the
       [--keep-dir] [--json]                 CALLING instance: the window dies, then
@@ -3962,20 +2872,14 @@ Usage:
       [--json]                              installed capabilities with health, effective
                                             layer bindings and activation, declared
                                             operations with availability; --home answers the
-                                            running home's captured bindings and their drift
-                                            from the current config
-  oats operation run <layer>:<name>          run an operation the effective provider of that
+                                            running home's recorded modules and their drift
+                                            from the deployment
+  oats operation run <layer>:<name>          run an operation the soul's core capability for that
       (--home <abs> | --soul <name> [--dir <d>])  layer declares (knowledge:harvest, knowledge:
-      [--arg k=v ...] [--json]              inspect ...): resolved from the home's captured
-                                            bindings or the scope's config, trust checked, the provider's
+      [--arg k=v ...] [--json]              inspect ...): resolved from the home's recorded
+                                            modules or the deployment's soul, trust checked, the provider's
                                             own command run in the home or scope, envelope
                                             relayed; a view answers {documents: [...]}
-  oats soul set <name> [--dir <scope>]       change an editable soul's launch defaults and/or
-      [--agents-root <abs>] [--runtime r]    instructions in place (soul.yaml lines replaced,
-      [--model m | --no-model]              everything else kept; AGENTS.md replaced from
-      [--yolo | --no-yolo] [--backend b]     --instructions-file); packaged souls are refused;
-      [--description d | --no-description]  the receipt carries before/after and sha256s
-      [--instructions-file <path>] [--json]
   oats launch-config list [--dir <scope>     named launch configurations effective at a scope,
       | --home <abs> | --soul <name>]       a home's recorded context or a soul's own scope:
       [--agents-root <abs>] [--json]        runtime, executable, args, env (values redacted,
@@ -3996,22 +2900,22 @@ Usage:
   oats update [--check] [--yes]              check npm for a newer kernel+pi bridge and
                                             optionally run the update; then run oats doctor
   oats sync [--dir <d>] [--json]             workspace model v2: observe the workspace named by
-      [--approve <id>@<version>]...         oats-local.yaml over its Git remote, confirm every
+                                            oats-local.yaml over its Git remote, confirm every
                                             member (reciprocal oats-membership.yaml), resolve
-                                            packages: to exact commits, ask executable approval
-                                            once per package version (TTY; otherwise list what
-                                            needs it and exit 2), write oats-lock.json (v3) and
-                                            report the diff. --approve approves exactly that
-                                            package at exactly that locked version without a
-                                            terminal (the digest is computed over the locked
-                                            tree; an id@version not in the lock is E_BAD_ARGS)
+                                            packages: to exact commits + integrity, write
+                                            oats-lock.json (v3) and report the diff. No approval
+                                            step: declaring a package in packages: is the trust
+                                            decision (--approve is E_BAD_ARGS)
   oats package add <id> <version|git:<repo>@<ref>>  edit packages: in oats-workspace.yaml when the
       | remove <id>  [--dir <d>]            workspace repo is the current checkout; otherwise
                                             print the line to add (the file travels through Git)
   oats workspace status [--dir <d>] [--json] membership table (confirmed / no-backlink /
-                                            cannot-read / backlink-elsewhere), packages, approval
-  oats capabilities [--dir <d>] [--json]     every non-private capability of every confirmed
-  oats souls [--dir <d>] [--json]            member + the locked packages, with origin
+                                            cannot-read / backlink-elsewhere), locked packages
+  oats capabilities [--dir <d>] [--json]     every capability of every confirmed member (a
+                                            private one is listed as repo-owned: usable only by
+                                            its own repo's souls) + the locked packages
+  oats souls [--dir <d>] [--json]            every soul of every confirmed member + external souls
+                                            (souls have no private mode), with origin
                                             (member <key> @ <commit> | package <id> v<ver>) and team
   oats instance git <instance> [--home <abs>] [--dir <d>] [--json]
                                              read-only Git observation of the instance's work
@@ -4020,10 +2924,6 @@ Usage:
   oats instance diff <instance> --file <id> --revision <rev> [--index-revision <rev>] [--home <abs>] [--dir <d>] [--json]
                                              bounded diff of one observed file; refuses when
                                              the tree moved since the observation
-  oats session recompose --home <abs> [--dry-run] [--json]
-                                             refresh a LIVE home's AGENTS.md from its current
-                                             canonical soul + context (same composer as spawn);
-                                             previous text retained; nothing restarted
   oats instance events <instance> [--limit <n>] [--since <iso>] [--json]
                                              typed lifecycle events (spawned, launched, stopped,
                                              restarted, retired, worktree-retained…) written by
@@ -4034,14 +2934,15 @@ Usage:
   oats instance stop <instance> --apply --plan-revision <rev> --idempotency-key <key>
                                              quiesce (SIGTERM, bounded, never escalated),
                                              children first; home/work/launch retained
-  oats readiness [--soul <n> [--agents-root <abs>]] [--home <abs>] [--verify-signatures] [--policy] [--json]
-                                             quartet installed|trusted|configured|enrolled for a scope,
-                                             a soul, or an instance home (captured homes refuse:
-                                             their readiness is the retained resolution's)
-                                             installed | trusted | configured | enrolled, each
+  oats readiness (--soul <n> | --home <abs>) [--policy] [--json]
+                                             readinessApi 2 for a soul or an instance home:
+                                             installed | configured | member | providers, each
                                              pass|fail|unknown|not-applicable with items and
-                                             remedies; signature status per artifact; enforced
-                                             child-spawn / worktree policy with origins
+                                             remedies; providers relays each bound provider's
+                                             own check ({status, problems, warnings});
+                                             --policy: enforced child-spawn / worktree policy
+                                             with origins (captured homes refuse: the
+                                             captured/portable path was removed in 0.26)
   oats retire <instance> --plan [--json]     what Remove would touch, with retention defaults
   oats retire <instance> [--plan-revision <rev> --idempotency-key <key>] [--discard-worktree] [--delete-branch]
                                              with a plan revision: refuses E_PLAN_STALE (fresh plan
@@ -4050,8 +2951,6 @@ Usage:
                                              <workspace>/.agents/worktrees/<repo>/<branch>)
                                              unless discarded; --delete-branch deletes the
                                              worktree's verified branch and implies discard
-  oats type add <name> [--description <d>]   declare an agent type (family) in config;
-  oats type list                             souls join via create --type / soul.yaml
   oats root                                  print this package's install root
                                             (adapters resolve the kernel from it)
 
@@ -4069,43 +2968,6 @@ The turn record (core — every conversation captured, searchable, replicated):
                                             design, repo checkout only; see
                                             packages/experimental/README.md
 
-  oats inspect --request <absolute-json-file> [--json]
-      [--emit-prepare-request <new-absolute-json-file>]
-                                            fresh source/workspace/member metadata; optional private
-                                            request export uses the existing fresh-request builder;
-                                            no provider execution or preparation authority
-  oats prepare --request <absolute-json-file> [--json]
-                                            complete public preparation input; no mixed flags,
-                                            inherited binding, implicit setup or launch authority
-  oats prepare --dir <abs> --source <git repo> --revision <ref> --export <path>
-      --alias <name> [--work <mode>] [--json]  prepare retained commands and curriculum,
-                                            no launch; provider gaps report incomplete
-  oats prepare --dir <abs> --workspace <git repo> --alias <advertised alias>
-      [--workspace-revision <ref>] [--work <mode>] [--json]
-                                            same preparation through workspace imports
-  oats inspect --deployment <abs> --resolution <id> [--composition] [--json]
-      [--helper <exact-map-key>]             inspect retained source/helper inputs, not today's configuration
-  oats trust <capability> --deployment <abs> --artifact-set <sha256-…> [--json]
-                                            approve one exact prepared artifact; use each
-                                            selections[].artifactSet for capability ids
-                                            in prepare's approvalRequired[] at that selection
-  oats trust <capability> --deployment <abs> --resolution <id> [--json]
-                                            explicitly approve that exact captured artifact
-  oats <namespace> <command> --deployment <abs> --resolution <id> -- [args…]
-                                            run the approved retained command; no ambient fallback
-  oats operation run <layer>:<name> --deployment <abs> --resolution <id>
-      [--home <abs>] [--arg k=v ...] [--retry-intent <saved-id>] [--json]
-                                            home actions admit distinct requests; explicit retry reuses intent
-                                            scope views stay read-only; scope mutation is not yet qualified
-  oats spawn <captured subject> --deployment <abs> --resolution <id>
-      --home <abs> --no-launch [--json]      create a fresh directory scaffold and run captured hooks
-  oats session inspect --deployment <abs> --resolution <id> --home <abs> --native-record <UUID> [--helper <exact-key>] --json
-                                           read-only Pi completion observation; not admission or readiness
-  oats session start|restart --deployment <abs> --resolution <id> --home <abs>
-      [--helper <exact-source-map-key>] [--request <abs-json>] [--retry-intent <saved-id>] [--json]
-                                            dispatch the owned captured home via existing native custody;
-                                            version1 request: backend/task/stopGraceMs, no model override
-
   oats <namespace> <command> [args…]         run an operational command only when its
                                             capability is active (e.g. oats okf harvest)