@awebai/oats 0.25.7 → 0.25.8

package/bin/oats.mjs

@@ -2938,7 +2938,7 @@ async function paneCmd() {
  * remotes, confirm membership, resolve `packages:`, approve (TTY) or list what
  * needs approval (exit 2), 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 setup expert are the operator's next steps, printed here. */
+ * clones and the operator expert are the operator's next steps, printed here. */
 async function onboardCmd() {
   const bail = (code, message, details) => (JSON_MODE ? jsonFail(code, message, details) : die(message));
   const usage = "usage: oats onboard [<dir>] --workspace <repo ref> [--json]   (or --dir <dir>)";
@@ -3015,11 +3015,11 @@ async function onboardCmd() {
   // (4) The taught layout as next steps (design doc §4), and the envelope.
   const standalone = synced.discovery.standalone === true;
   const members = synced.report.members;
-  // The setup expert is suggested only when THIS workspace lists a soul by that name (a
+  // The operator expert is suggested only when THIS workspace lists a soul by that name (a
   // confirmed member's or, standalone, the repo's own); otherwise any listed soul is spawnable.
   const soulNames = synced.items.souls.map((s) => s.name);
-  const setupExpert = soulNames.includes("oats-setup-expert");
-  const spawnHint = setupExpert ? `oats spawn oats-setup-expert --dir ${shortPath(dir)}` : null;
+  const setupExpert = soulNames.includes("oats-operator-expert");
+  const spawnHint = setupExpert ? `oats spawn oats-operator-expert --dir ${shortPath(dir)}` : null;
   const anySoulHint = `spawn any listed soul: oats spawn <soul> --dir ${shortPath(dir)}${soulNames.length ? ` (e.g. ${soulNames.slice(0, 3).join(", ")})` : ""}`;
   // A member's clone goes beside oats-local.yaml under its repo name; `agents/` is the instance
   // homes, so a member called "agents" is cloned as `agents-repo/` (design doc §4). The HOST is
@@ -3060,7 +3060,7 @@ 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 setup expert to guide the rest (souls, teams, provider settings, approvals):" : "No soul named oats-setup-expert is listed here —"}
+  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;
 }
@@ -3911,7 +3911,7 @@ Usage:
       [--json]                               and agents/, then runs the oats sync path (lock v3;
                                             exit 2 while approvals are pending) and prints the
                                             next steps (clone members you work IN, spawn
-                                            oats-setup-expert); creates no soul, spawns nothing
+                                            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)

package/docs/design/2026-09-20-redesign-program-board.md

@@ -2,7 +2,7 @@
 
 **Purpose:** the one accurate view of every work stream in the redesign, what is on main, what is in flight, who owns it, and what blocks it. Lead: `oats-expert` (redesign lead). Updated whenever anything merges, is returned, or reality changes. Older per-lane boards are superseded by this file.
 
-**Last update:** 2026-09-24 13:30Z · **0.25.0–0.25.6 PUBLISHED** (0.25.6 = decision 27 kernel half + Desktop 10B-0 terminal owner leases, native gate 23/23) (workspace model A–C; team-review fixes; operator-rebuild round; OATS_SOUL_ID; quarantine-retry fix; launch meta + catalog pins) · **OKF v2.1.4 + oats.aweb v1.12.0 TAGGED and pinned** · **decision 27 accepted; K1′/K1″/K2 kernel PR next** · **oats.aweb 1.13.0 (#110) queued** · **Desktop 10B-0 resumed** · Phase D plan next · **Desktop engineer paused by the human** (10B-0 uncommitted foundation preserved; resume is the human's call; 0.24.14 to be cut from a maintenance branch off `e5cdaf95` when its PR lands) · parity pipeline ⏸.
+**Last update:** 2026-09-24 14:10Z · **0.25.0–0.25.7 PUBLISHED** (0.25.7 = v2 deployment root is a configuration boundary) (0.25.6 = decision 27 kernel half + Desktop 10B-0 terminal owner leases, native gate 23/23) (workspace model A–C; team-review fixes; operator-rebuild round; OATS_SOUL_ID; quarantine-retry fix; launch meta + catalog pins) · **OKF v2.1.4 + oats.aweb v1.12.0 TAGGED and pinned** · **decision 27 accepted; K1′/K1″/K2 kernel PR next** · **oats.aweb 1.13.0 (#110) queued** · **Desktop 10B-0 resumed** · Phase D plan next · **Desktop engineer paused by the human** (10B-0 uncommitted foundation preserved; resume is the human's call; 0.24.14 to be cut from a maintenance branch off `e5cdaf95` when its PR lands) · parity pipeline ⏸.
 
 Legend: ✅ on main/published · 🔄 in flight (PR/branch) · 🟡 preserved, not adopted · ⬜ not started · ⛔ blocked
 

package/docs/design/2026-09-24-desktop-phase-f-boundary.md

@@ -81,6 +81,22 @@ identity.mode=… identity.resident=…` (decision 27 — there is no kernel fla
 `SPAWN_ARG_RULES` gains one `provider` rule (capability id, dotted key, value
 grammar); no identity-named rules. Work mode select includes `workspace`.
 
+**F3 amended by the human (2026-09-24). This supersedes design frame 02 and the
+text above wherever they differ.** The dialog leads with the **instance name**:
+the purpose field becomes a name field that shows `<soul>-<purpose>` live and
+then the kernel's final name from the preview. A no-prefix toggle maps to
+`spawn --name <slug>`, gated on the `spawn-name` feature; `--purpose` stays the
+default. **Runtime and model** are always visible, with their resolved value and
+its source. **Work** comes from the soul's `work:` mode, and a `checkout` soul is
+offered "Use a worktree instead?" (`--work worktree`). There is **no**
+modules/capabilities list and no attach-knowledge / child-spawn / open-PR
+toggles, because those behaviours come from capabilities. There is **no**
+preview button either. The preview runs in the background to fill the real
+defaults, and apply still binds with `--expect-decision` (`E_DECISION_STALE`
+re-previews). A collapsed **Advanced** section holds harness permissions, launch
+config, relation, messaging identity (`--provider <cap> identity.mode=…`,
+decision 27), branch/base overrides and the execution server. Every modal gets a darker backdrop.
+
 **F4 — Instance card and roster on v2 facts.** The served-identity line (`acts
 as <address> via grant, expires <t>` / `alias <a> on <team>`); module rows with
 "moved since" markers and a **re-spawn** action (preview → apply, then retire

package/docs/design/2026-09-24-phase-d-plan.md

@@ -22,7 +22,7 @@ pushes. Agreed by both on 2026-09-24:
 | oats.aweb 1.13.0 re-land end to end | Antares | assigned |
 | D1 operator node + integrations node | Antares | assigned (draft PR `d1/operator-node` handed over) |
 | aweb and okf package-expert seams | Antares | assigned |
-| D2, D3, D4, desktop + kernel bundle migrations (D1 remainder) | Antares | assigned (both humans agreed, 2026-09-24). D2's machine-bound onboard of the lead's deployment is run by the lead on Antares' word; kernel gaps come to the lead as asks. |
+| D2, D3, D4, desktop + kernel bundle migrations (D1 remainder) | lead, driven by the child instance `oats-expert-phase-d` | assigned (human, 2026-09-24: picked up by the lead's side after all, so as not to wait on the other deployment's human). The lead reviews and merges; Class B items go to Antares for ACK; D3's aweb/okf seams are drafted by the driver and settled with Antares. **Antares is a REQUIRED cross-reviewer** on D4's `oats.setup` rewrite (it must not drift from the operator node) and on D3's `aweb-expert` and `okf-expert` souls (the seams); the rest of the driver's PRs it reads without gating. |
 
 **Push protocol.**
 - **Class A** — notify after, one line: stewardship, docs and knowledge inside
@@ -118,14 +118,44 @@ for, never named by convention — decision 9) is the acceptance: `oats onboard`
 
 ### D3 — Souls to `souls/<name>` and the six package-expert souls (decision 20)
 
-Each package repo carries `souls/<pkg>-expert` (okf-expert, aweb-expert,
-jira-expert, linear-expert, authoring-expert, dev-expert), the expert in that
-package, with a node in the central base from day one. **Seams named in the
-charters** (roster amendment): `aweb-expert` READS
+Each package repo carries `souls/oats-<pkg>-expert` (oats-okf-expert,
+oats-aweb-expert, oats-jira-expert, oats-linear-expert, oats-authoring-expert,
+oats-dev-expert), the expert in that package, with a node in the central base
+from day one. **Messaging (human, 2026-09-24; supersedes the lead's per-soul rule):**
+`oats.aweb` is the workspace's messaging **default**
+(`defaults.messaging: { oats.aweb: { from: package } }`, oats#140); a soul
+without messaging says `messaging: none`. The human calls it "the most
+important capability, and most workspaces will use it as default", so the
+provider must work well as a default. Open items (oats.aweb unless noted):
+an unconfigured default must not make every soul unspawnable (onboarding sets
+the messaging root before the first spawn, and/or an unconfigured provider
+reports what is missing instead of refusing); error texts and `setup` must stop
+pointing at `oats-config.yaml`; the deployment names its messaging root
+explicitly rather than by search; `aw mail` usable from `work/`; retired aliases
+reusable. Kernel (lead): in v2 the team scope is the deployment directory and
+the team id comes from the messaging payload, not the classic `team:` block.
+#140 merges together with the first answer to the unspawnable-default item.
+**Teams (human, 2026-09-24): seamless by default.** (R1) Every person gets a
+**personal team per workspace**, created on first use with no invite and no
+manual initialisation — two people, or one person on two workspaces, get
+separate teams; stable across one person's machines. (R2) When a soul whose
+`team:` label the workspace maps to a shared team (`messaging.byTeam.<label>.team`)
+is spawned, the instance **joins that team seamlessly**. Authorization for R2
+(what entitles a person to join without an invite) is oats.aweb's design call
+with the aweb project, fail-closed and visible when the entitlement is missing.
+Kernel (lead): pass the soul's team label and the workspace identity so the
+provider derives the personal team deterministically; an unmapped team means
+"personal". The onboarding skill's manual invite-then-join step is the 1.12.0
+path and is rewritten when the provider ships R1/R2.
+**Naming (lead, 2026-09-24):** the `oats-` prefix on all six —
+it matches the repository names and the roster's `oats-kernel-`/`oats-desktop-`/
+`oats-operator-expert`, and it keeps instance aliases from colliding with the
+messaging project's own `aweb-expert` soul on a shared team. **Seams named in the
+charters** (roster amendment): `oats-aweb-expert` READS
 `aweb-protocol-expert` in base `aweb-oss-knowledge` (repo
 `github.com/awebai/aweb`, root `knowledge/`, branch `main`, OKF 2.1.x
 descriptor at `knowledge/okf-base.json`; owner `1913b77b-…`) through a
-read-only store reference; `okf-expert` names its seam to the knowledge-theory
+read-only store reference; `oats-okf-expert` names its seam to the knowledge-theory
 material in `oats-expert`. Whether the aweb bookshelf decisions the program
 rests on are published into that node is the aweb side's call (asked).
 
@@ -140,6 +170,27 @@ rule, the rebuild guide as procedure with the operator node as rationale.
 Developer souls in `oats.dev` gain `promotesTo: <node>` (roster amendment);
 the harvester delivers to that node as a PR the owning expert reviews.
 
+**D4 also removes the legacy the v2 model already declared gone** (human,
+2026-09-24; boundary §3b's native-rework rule applied to the repository):
+- **Docs, skills, examples** (driver, in D4): delete what v2 removed rather than
+  rewriting it (e.g. the OAS migration guide, the legacy Desktop succession
+  doc, `oats-config.yaml` examples, the `oats-config` skill); rewrite what
+  survives against `oats-local.yaml` and the workspace file; every remaining
+  mention of `oats-config.yaml` either describes its removal or is gone.
+- **Kernel** (lead, one Class B PR after D2 lands, because the OATS workspace
+  itself stops reading `oats-config.yaml` only once D2 converts it): the
+  `oats-config.yaml` scope chain and its readers, the `local-agents/` and
+  `tmp-agents/` layouts, the OAS-scope probes, the installed-capability tier
+  remnants. Removed, not flagged; the `REMOVED_VERBS` answers stay.
+- **In-repo package copies** (`capabilities/oats-{okf,aweb,jira,linear,authoring}`)
+  are NOT removed in D4: `package.json` ships `capabilities/` as the kernel's
+  bundled providers, pinned by the mirror-parity, release-packaging and
+  clean-room tests. Whether 0.26.0 still bundles them is a release decision
+  for D5 (lead); until then they stay unmarked. `private` becomes a schema key
+  (the kernel already reads it); `oats-review` is marked private.
+- **Legacy souls** (`agents/*` and their knowledge bundles) are NOT part of D4:
+  they go when the live instances linking them retire (human rule).
+
 ### D5 — Catalog update and 0.26.0
 
 Catalog pins for the new package versions; **widen Desktop `ACCEPT_RANGE` and

package/docs/desktop-succession.md

@@ -8,7 +8,7 @@ the OATS Desktop app (`packages/desktop/` in the framework repo):
 |---|---|
 | `oats.web` marketplace capability (`oats web start`, browser panel) | OATS Desktop app — the same zero-dependency loopback server is bundled at `packages/desktop/server/` and spawned by the app |
 | `oats pane` CLI command and the Control Pane TUI | OATS Desktop app (Active overview / instance roster) |
-| `@awebai/oats/control-pane` package export (`lib/control-pane/model.mjs`) | The roster model moved into `packages/desktop/server/model.mjs`; it is no longer a public kernel export |
+| `@awebai/oats/control-pane` package export (`lib/control-pane/model.mjs`) | The roster model moved into the Desktop app; under workspace model v2 the app reads the kernel's `oats status --json` instead ([deployment model](../packages/desktop/docs/desktop-deployment-model.md)). It is not a public kernel export |
 
 ## Migrating a deployment that used `oats.web`
 
@@ -45,9 +45,9 @@ solarized) exist in the app's theme system.
 `import ... from "@awebai/oats/control-pane"` no longer resolves. The
 model's pure helpers (`readMarkdownSection`, `parseTmuxWindows`,
 `parseGitStatus`, `parseGitDiffStat`, `buildConstellation`, `relativeAge`)
-live in `packages/desktop/server/model.mjs`, which is private to the desktop
-app. If you depended on this export, vendor the helpers or open an issue —
-no known external consumer existed at removal time.
+moved into the private Desktop app and were retired with its workspace-model v2
+rebuild. If you depended on this export, vendor the helpers from a released tag
+or open an issue — no known external consumer existed at removal time.
 
 ## Release gating (maintainers)
 

package/docs/release-notes/v0.25.8.md

@@ -0,0 +1,48 @@
+# OATS 0.25.8
+
+## Fixed
+
+- **Desktop: quotes are escaped in attribute contexts** (#139). The views share
+  one escaper (`escapeHtml`) for element content and attribute values.
+
+- **The roster reports an instance where it actually is.** `oats status`
+  reports each instance at the directory the kernel enumerated
+  (`<soul dir>/instances/<name>`), under that directory's name. An
+  `instance.json` whose `home` or `instance` disagrees no longer relocates or
+  renames the instance; the disagreeing values appear only as the diagnostics
+  `recordedHome` / `recordedInstance`. Before this, a hostile or corrupted
+  `instance.json` could make every consumer that acts on `home` (retire,
+  `inspect --home`, the Desktop's file roots) target a path outside the
+  deployment. Found by the Desktop engineer in Phase F slice F1.
+
+## Added
+
+- **Team facts for workspace-model hooks** (human decisions 2026-09-24:
+  `oats.aweb` is the messaging default; teams are seamless). A workspace
+  deployment has no classic `team:` block, so lifecycle hooks of a workspace
+  spawn now receive: `OATS_TEAM_SCOPE` = the deployment directory;
+  `OATS_TEAM_ID` = the messaging slot's merged payload `team` (workspace base ⊕
+  `byTeam[<soul team>]` ⊕ soul ⊕ host ⊕ spawn), **empty when no shared team is
+  mapped — meaning "personal"**; and new `OATS_TEAM_LABEL` (the soul's team
+  label), `OATS_WORKSPACE_NAME` and `OATS_WORKSPACE_KEY` (canonical repository
+  key), so a messaging provider can derive a personal team per person per
+  workspace deterministically. Classic deployments are unchanged.
+- **Desktop F2: Capabilities, Sources, sync and approval, onboarding** (#143).
+  The Workspace view gains a Capabilities table (Capability | Status | Used
+  by, from `oats capabilities --json`, filtered by team and source) and a
+  Sources tab. It can run `oats sync` and approve pending packages: the Desktop
+  admits an approval only when its (id, version, executables digest) exactly
+  match the latest sync report it holds, and refuses a mismatch with
+  `E_APPROVAL_STALE`. A picked folder that isn't yet a workspace can be
+  onboarded through single-use offers held by the main process. The 0.24
+  Deployment inventory and Workspace readiness blocks are removed.
+- **Desktop: design parity with Redesign v3 and brand artwork** (#137, #128).
+  The Desktop F1 deployment model on kernel JSON (#126) is included too.
+- **`oats.aweb` is the workspace messaging default** (#140, human decision).
+  The onboarding skill makes messaging setup its own step before the first
+  spawn (#141).
+- **The onboarding next-step hint names `oats-operator-expert`** (#134).
+- **Phase D:**
+  - The OATS repository hosts a workspace-model workspace (D2, #127).
+  - `oats-operator-expert` and `integrations-expert` souls, with the experts' instructions on the workspace model (D3, #129).
+  - `oats.core` and `oats.setup` rewritten for the workspace model (D4, #133).

package/injects/instance-boundary.md

@@ -6,24 +6,22 @@ hook as `$OATS_INSTANCE_HOME`. It is not your user home (`~`), not the repositor
 root, and not the work tree. Anything that says "your home" means this directory.
 
 - **Your brain and your state live here**: `AGENTS.md` (your composed
-  instructions), `soul/` (your durable knowledge), `TASK.md` (this task),
-  `instance.json` (what you were given and from where), and whatever working
-  state your role keeps — your knowledge layer names those files, if you have
-  one. They belong here, not in the work tree.
+  instructions), `TASK.md` (this task), `instance.json` (what you were given
+  and from where), and whatever working state your role keeps — your knowledge
+  layer names those files, if you have one. They belong here, not in the work
+  tree.
 - **Run OATS operational/lifecycle commands, and commands from active
   capabilities, from instance home** — `oats status`, `oats doctor`, `oats spawn`,
-  `oats retire`, and whatever your own capabilities add; for example, when the
+  and whatever your own capabilities add; for example, when the
   aweb messaging capability is active, run `aw` there too. They resolve their
   scope from the directory you run them in, so running them from the work tree
   points them at the wrong deployment. To act on a different package or config
   scope deliberately, pass an explicit resolved path: `oats <cmd> --dir <path>`.
-- **The home's `soul` link is not your edit surface.** It is there so you can
-  READ your durable knowledge. Writing through it changes durable state outside
-  your branch, where no review sees it and nothing records what changed or why.
-  If your TASK is to change soul content that lives in this repository, that is
-  ordinary code work — do it on tracked paths under `work/`, reviewed like the
-  rest. How your own learnings reach your soul is your knowledge layer's
-  business, and its instructions below say so if you have one.
+- **Soul work is repository work.** If your TASK is to change soul content that
+  lives in this repository, that is ordinary code work — do it on tracked paths
+  under `work/`, reviewed like the rest. How your own learnings reach your soul
+  is your knowledge layer's business, and its instructions below say so if you
+  have one.
 
 **`<instance-home>/work` is your repository or workspace view** — whatever your
 work mode grants you of the code.

package/injects/oats.md

@@ -1,10 +1,10 @@
 ## You run on OATS
 
 You are an agent instance in the OATS (Open Agent Team Specification) framework.
-You incarnate a durable soul (`./soul/`), you work in `./work/`, and you can
-be retired when your task ends. The **oats** skill teaches the essentials —
-your home layout, the agent roster (`oats status`), spawning and
-retiring instances (only when instructed), inspecting your configuration
+You incarnate a durable soul and you work in `./work/`.
+The **oats** skill teaches the essentials —
+your home layout, the agent roster (`oats status`), spawning
+instances (only when instructed), inspecting your configuration
 (`oats doctor`, `./instance.json`), and your lifecycle. **Load the oats skill
 before your first `oats` command of a session** and any time you reason about
 agents, spawning, or the framework itself — do not guess `oats` flags or

package/lib/core.mjs

@@ -4299,7 +4299,8 @@ export function composeInstanceAgentsMd(soulDir, contextDir, soulName, workMode,
     resolved.capabilities = Array.isArray(prepared.capabilityRows) && prepared.capabilityRows.length
       ? prepared.capabilityRows
       : plannedCapabilityRows(prepared.resolution);
-    resolved.workspace = { key: prepared.discovery?.key ?? null, commit: prepared.discovery?.commit ?? null, standalone: prepared.discovery?.standalone === true, revision: prepared.resolution.revision, team: prepared.resolution.soul?.team ?? null, slots: prepared.resolution.slots };
+    resolved.workspace = { key: prepared.discovery?.key ?? null, name: prepared.discovery?.workspace?.name ?? null, deployment: prepared.deployment ?? null, commit: prepared.discovery?.commit ?? null, standalone: prepared.discovery?.standalone === true, revision: prepared.resolution.revision, team: prepared.resolution.soul?.team ?? null, slots: prepared.resolution.slots };
+    resolved.payloads = prepared.resolution.payloads ?? {};
     resolved.layers = Object.fromEntries(Object.entries(prepared.resolution.slots || {}).map(([slot, mod]) => [slot, mod ? { capability: mod } : null]));
   }
   const wanted = [];
@@ -4837,6 +4838,28 @@ export function stableSoulId({ soulId, home, soulDir, agentName } = {}) {
 }
 export const workspaceSoulId = (repoKey, name) => `${repoKey}#${name}`;
 
+/** The team facts a lifecycle hook receives. Classic deployment: the config
+ * chain's `team:` block (name, id, the declaring scope). Workspace model: there is
+ * no `team:` block — the team SCOPE is the deployment directory, the team ID is the
+ * messaging slot's merged payload `team` (workspace base ⊕ byTeam[<soul team>] ⊕
+ * soul ⊕ host ⊕ spawn), and the provider also gets the soul's team LABEL and the
+ * workspace's name and canonical key, so it can derive a per-person, per-workspace
+ * personal team when no shared team is mapped (empty OATS_TEAM_ID = "personal").
+ * Human decision 2026-09-24 (messaging default; seamless teams). */
+export function teamEnv(resolved) {
+  const ws = resolved?.workspace;
+  if (!ws || typeof ws !== "object") {
+    return { OATS_TEAM_NAME: resolved?.team?.name || "", OATS_TEAM_ID: resolved?.team?.id || "", OATS_TEAM_SCOPE: resolved?.team?.scope || "" };
+  }
+  const messaging = ws.slots?.messaging;
+  const payload = messaging ? resolved.payloads?.[messaging] : null;
+  const teamId = payload && typeof payload === "object" && typeof payload.team === "string" ? payload.team : "";
+  return {
+    OATS_TEAM_NAME: "", OATS_TEAM_ID: teamId, OATS_TEAM_SCOPE: ws.deployment || "",
+    OATS_TEAM_LABEL: typeof ws.team === "string" ? ws.team : "",
+    OATS_WORKSPACE_NAME: typeof ws.name === "string" ? ws.name : "", OATS_WORKSPACE_KEY: typeof ws.key === "string" ? ws.key : "",
+  };
+}
 export function runLifecycleHooks(event, { home, instance, agentName, soulDir, soulId, contextDir, workspaceDir, rootDir, resolved, priorMeta = {}, extraEnv = {}, assertRoots }) {
   const results = { meta: {}, briefs: [], warnings: [], order: [], launch: {}, env: {}, failures: [], contributions: [] };
   const envOwners = new Map();
@@ -4866,7 +4889,7 @@ export function runLifecycleHooks(event, { home, instance, agentName, soulDir, s
           OATS_EVENT: event, OATS_INSTANCE: instance, OATS_INSTANCE_HOME: home, OATS_HOME: home, OATS_AGENT: agentName,
           OATS_CAPABILITY: cap.id, OATS_LAYER: cap.layer || "", OATS_ROOT: rootDir || "",
           OATS_SOUL: soulDir || "", OATS_SOUL_ID: stableSoulId({ soulId, home, soulDir, agentName }), OATS_CONTEXT: contextDir, OATS_WORKSPACE: workspaceDir || "", OATS_LEVEL: cap.level || "",
-          OATS_TEAM_NAME: resolved.team?.name || "", OATS_TEAM_ID: resolved.team?.id || "", OATS_TEAM_SCOPE: resolved.team?.scope || "",
+          ...teamEnv(resolved),
           ...extraEnv,
           // Hooks also run through direct core callers (not only bin/oats).
           // Author this from the running kernel, never PATH, ambient env or
@@ -7428,7 +7451,16 @@ export function listInstances(root, tmuxSession = DEFAULT_TMUX_SESSION) {
           catch (error) { liveness = { running: null, runtimeState: "unreachable", runtimeError: error.message }; }
         }
         const identity = servedIdentityOf(meta);
-        return { ...meta, ...(identity ? { identity } : {}), ...(meta.launch && typeof meta.launch === "object" ? { launch: redactLaunchRecipe(meta.launch) } : {}), ...(typeof meta.command === "string" ? { command: redactLaunchCommand(meta.command) } : {}), ...liveness, ...(rollbackIncomplete ? { rollbackIncomplete } : {}), ...(retirePending ? { retirePending } : {}) };
+        // The home IS the directory enumerated here, and the instance its name:
+        // a file inside it cannot relocate or rename itself in the roster (every
+        // consumer acting on `home` — retire, inspect --home, the Desktop's file
+        // roots — would inherit the claim). A disagreeing claim survives only as
+        // a diagnostic.
+        const claims = {
+          ...(meta.home !== undefined && meta.home !== home ? { recordedHome: meta.home } : {}),
+          ...(meta.instance !== undefined && meta.instance !== e.name ? { recordedInstance: meta.instance } : {}),
+        };
+        return { ...meta, ...claims, home, instance: e.name, ...(identity ? { identity } : {}), ...(meta.launch && typeof meta.launch === "object" ? { launch: redactLaunchRecipe(meta.launch) } : {}), ...(typeof meta.command === "string" ? { command: redactLaunchCommand(meta.command) } : {}), ...liveness, ...(rollbackIncomplete ? { rollbackIncomplete } : {}), ...(retirePending ? { retirePending } : {}) };
 
       });
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awebai/oats",
-  "version": "0.25.7",
+  "version": "0.25.8",
   "description": "OATS (Open Agent Team Specification) — durable souls, disposable instances, targetable capability packages, and the runtime-neutral oats CLI/kernel.",
   "keywords": [
     "agents",
@@ -36,8 +36,6 @@
     "docs/",
     "README.md",
     "package-catalog.json",
-    "souls/oats-setup-expert/soul.yaml",
-    "souls/oats-setup-expert/AGENTS.md",
     "packages/record/bin/",
     "packages/record/lib/",
     "packages/record/docs/",

package/souls/oats-setup-expert/AGENTS.md

@@ -1,60 +0,0 @@
-# OATS Setup Expert
-
-Help an operator turn an empty deployment into a deliberately configured OATS
-workspace. Explain the next small decision, inspect the existing state, obtain
-approval for effects, and verify the result before moving on. Do not replace
-working deployments or turn setup into an implicit enrollment operation.
-
-## Your supplied procedures
-
-- Load **oats-workspace-setup** for workspace/source discovery and adoption:
-  declare, inspect, prepare, approve, scaffold and start are different steps.
-- Load **oats-config** for version-scoped classic configuration and targeting;
-  never use its cascade to fill a missing captured input.
-- Load **oats-packages** for official package discovery, acquisition, exact locks,
-  executable approval and updates.
-- Load **oats-operate** for lifecycle, directory boundaries and supported CLI
-  operations; load **oats-souls** for source editions, roster and relations.
-
-Use the procedures actually included in your composition. Do not fetch a current
-skill or invent a command when an older installed version lacks a feature.
-
-## Setup sequence
-
-1. Establish the operator's intended deployment, work target and workspace/source
-   separately. Inspect existing configuration, locks and souls before proposing
-   changes. A workspace is a shared definition, not a shared live runtime.
-2. Explain `oats-workspace.yaml` and each member's separate `oats.yaml` exports
-   and backlink. Check reciprocal observations; discovery is neither membership
-   enrollment nor capability activation. Pin imports only after a source is
-   published at a real reviewed revision; never invent a future commit or tag.
-3. Select capabilities and their exact sources with the operator. New souls
-   declare removable `oats.core` explicitly. Do not add knowledge, messaging or
-   tasks merely because the package was discovered or acquired.
-4. Keep package acquisition, executable approval, provider configuration and
-   native account/team authorization distinct. Inspect the exact artifact and
-   its effects before asking for approval. An official catalog entry is not a
-   blanket grant to execute hooks or change credentials.
-5. Use the supported prepare/approve/scaffold/start path for retained portable
-   adoption. Verify complete resources and required provider readiness before
-   native effects. A successful inspection, scaffold or submitted command is
-   not proof of a working session, message delivery or accepted learning.
-
-## Bootstrap and safety boundaries
-
-This setup role has no hard knowledge or messaging dependency: it must be useful
-before OKF or aweb is configured. Its defaults permit none. That does NOT permit
-removing another soul's hard requirements to make a failing launch appear ready.
-
-A classic local bootstrap copy is not a captured preparation or retained source
-identity. Say which path created your current soul and do not claim one path's
-receipts as evidence for the other. Keep a source edition and an operator-local
-configuration distinct; never commit live identities, machine paths, accounts,
-private bindings or credentials into exported source definitions.
-
-Never auto-launch a model session, enable dangerous permissions, enroll an
-identity, install a host service, overwrite an existing soul or migrate knowledge
-without the operator's explicit instruction. Use ordinary native runtime auth;
-missing auth is a human login step, not permission to inspect, copy or wrap
-credentials. Preserve existing instances, pending jobs, locks and failed receipts.
-Report unsupported operations or infrastructure faults instead of bypassing them.

package/souls/oats-setup-expert/soul.yaml

@@ -1,14 +0,0 @@
-schemaVersion: 1
-name: oats-setup-expert
-description: Guide an operator through OATS workspace adoption and explicit capability setup.
-work: directory
-requires:
-  capabilities:
-    oats.core:
-      source: repo:oats-package
-    oats.setup:
-      source: repo:oats-package
-defaults:
-  knowledge: none
-  messaging: none
-  tasks: none