@awebai/oats 0.69.3 → 0.69.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (50) hide show
  1. package/bin/oats.mjs +68 -49
  2. package/docs/configuration.md +12 -0
  3. package/docs/desktop-cli-api.md +8 -1
  4. package/docs/execution-targets.md +25 -3
  5. package/docs/implementation.md +42 -3
  6. package/docs/integrations.md +2 -2
  7. package/docs/knowledge.md +9 -6
  8. package/docs/named-test-runs.md +4 -2
  9. package/docs/official-catalog.md +6 -6
  10. package/docs/packages.md +14 -14
  11. package/docs/release-lane.md +25 -18
  12. package/docs/release-notes/v0.69.4.md +73 -0
  13. package/docs/release-notes/v0.69.5.md +146 -0
  14. package/docs/souls-and-instances.md +2 -2
  15. package/docs/tui.md +2 -1
  16. package/docs/upgrading.md +16 -5
  17. package/docs/workspaces.md +2 -2
  18. package/lib/agents-root.mjs +51 -0
  19. package/lib/automation-api.mjs +7 -0
  20. package/lib/automation-scope.mjs +35 -0
  21. package/lib/automations.mjs +2 -1
  22. package/lib/compile-cache.mjs +36 -0
  23. package/lib/core.mjs +39 -1348
  24. package/lib/deployment-path.mjs +127 -0
  25. package/lib/deployments.mjs +2 -2
  26. package/lib/drift.mjs +95 -0
  27. package/lib/hot-reads.mjs +131 -0
  28. package/lib/instance-address.mjs +21 -0
  29. package/lib/instance-lifecycle.mjs +4 -16
  30. package/lib/instance-listing.mjs +730 -0
  31. package/lib/instance-resolution.mjs +5 -166
  32. package/lib/materialize.mjs +2 -87
  33. package/lib/member-clone.mjs +188 -0
  34. package/lib/package-catalog.mjs +93 -0
  35. package/lib/packages.mjs +4 -24
  36. package/lib/reserved-launch-env.mjs +20 -0
  37. package/lib/resolved-deployment.mjs +1 -1
  38. package/lib/schedule.mjs +5 -29
  39. package/lib/semver.mjs +12 -0
  40. package/lib/servers.mjs +10 -12
  41. package/lib/session-end.mjs +3 -2
  42. package/lib/session-inspect.mjs +219 -0
  43. package/lib/soul-listing.mjs +216 -0
  44. package/lib/status-words.mjs +30 -0
  45. package/lib/version.mjs +9 -0
  46. package/lib/write-file-atomic.mjs +28 -0
  47. package/package-catalog.json +5 -5
  48. package/package.json +1 -1
  49. package/packages/tui/lib/store.mjs +7 -3
  50. package/skills/oats-getting-started/SKILL.md +3 -3
@@ -0,0 +1,216 @@
1
+ /** The souls under an agents root and the homes of an instance name among them: listAgents reads each
2
+ * soul.yaml (the flat reader, and the YAML parser for a workspace-model soul), findInstanceHomes finds
3
+ * the homes contained in them. A leaf (awebai/oats#1630): `oats instance events` and `instance waiting`
4
+ * resolve a home without loading core.mjs, which re-exports these. */
5
+ import { existsSync, realpathSync, readdirSync, readFileSync } from "node:fs";
6
+ import { join, dirname, basename, resolve, isAbsolute } from "node:path";
7
+ import { oatsError } from "./errors.mjs";
8
+ import { parseConfigData } from "./config-data.mjs";
9
+
10
+ export const RESERVED = new Set(["bin"]);
11
+
12
+ /** The agent dirs directly under an agents root that hold no soul: capability-defined
13
+ * agents (their soul is read-only in a module; the dir holds only instances/). */
14
+ function capabilityAgentDirs(root) {
15
+ let entries; try { entries = readdirSync(root, { withFileTypes: true }); } catch { return []; }
16
+ return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !RESERVED.has(e.name) && !existsSync(join(root, e.name, "soul", "soul.yaml")))
17
+ .map((e) => ({ name: e.name, dir: join(root, e.name) }));
18
+ }
19
+
20
+ // ---------- yaml-ish ----------
21
+ /** `__proto__` is never data in a plain-object mapping: assigning it REWRITES
22
+ * the parsed object's prototype, so the entry vanishes from `Object.keys` —
23
+ * past every key validator — while still answering property reads (a document
24
+ * could smuggle an unvalidated `name:` or `capabilities:` that way). No OATS
25
+ * document has a use for the key, so the readers refuse it rather than parse
26
+ * it: fail closed, never silently drop.
27
+ *
28
+ * THE single refusal, shared by the readers and by every WRITER that assigns an
29
+ * operator-supplied key into a config map — a write path that let the inherited
30
+ * setter swallow the entry and then reported success would be the same defect
31
+ * with a friendlier face. The readers parse strings and cannot name the
32
+ * document, so `where` is filled in by whoever holds the file
33
+ * (`withConfigFile`); the raw message therefore says "mapping key", not
34
+ * "oats-config key" — soul.yaml and skill frontmatter go through here too. */
35
+ export function assertSafeConfigKey(key, where) {
36
+ if (key === "__proto__") {
37
+ throw oatsError("unsafe-config-key", `unsupported mapping key "__proto__"${where ? ` in ${where}` : ""} — "__proto__" cannot be a mapping key in an OATS document (it rewrites the parsed object's prototype instead of becoming data)`, where ? [{ file: where }] : undefined);
38
+ }
39
+ return key;
40
+ }
41
+ /** Run a reader that may raise the typed key refusal and re-raise it naming the
42
+ * FILE. Every caller with a path in hand wraps its read — the readers parse
43
+ * strings and cannot name a document — so the CLI boundary can print one line
44
+ * the operator can act on.
45
+ *
46
+ * The insertion uses a REPLACER FUNCTION, never a replacement string: `$&`,
47
+ * `$'`, `` $` `` and `$1` are substitution syntax in `String.replace`, so a
48
+ * config path containing one of them (`/tmp/$&/oats-config.yaml` — legal on every
49
+ * POSIX filesystem) was expanded against the match and the reported filename
50
+ * came out corrupted. A function receives the path as data. */
51
+ export function withConfigFile(file, read) {
52
+ try { return read(); }
53
+ catch (e) {
54
+ if (e?.code !== "unsafe-config-key" || e.provenance) throw e;
55
+ throw oatsError(e.code, e.message.replace(" — ", () => ` in ${file} — `), [{ file }]);
56
+ }
57
+ }
58
+
59
+ const yamlKey = (key) => assertSafeConfigKey(key);
60
+ export function parseYamlFlat(text) {
61
+ const o = {};
62
+ for (const line of text.split("\n")) {
63
+ const m = line.match(/^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*?)\s*(#.*)?$/);
64
+ if (m) o[yamlKey(m[1])] = m[2].replace(/^["']|["']$/g, "");
65
+ }
66
+ return o;
67
+ }
68
+
69
+ /** The `_`-prefixed namespace on a parsed document belongs to the KERNEL: `_dir`,
70
+ * `_origin`, `_package`, `_capabilityLock`, `_soulDir` … are the
71
+ * kernel's own statements ABOUT an artifact — where it was found, which lock row
72
+ * governs it, whether it is trusted. They are internal annotations, so they must
73
+ * be unforgeable: an artifact that can write them into its own on-disk document
74
+ * asserts its own provenance. That was reachable — a capability whose `oats.json`
75
+ * declared `"_capabilityLock": {...}` spread straight through `{ ...m }` and
76
+ * silenced doctor's "in installed/ but has no lock entry" warning for an
77
+ * artifact nothing locks.
78
+ *
79
+ * So every parsed document that later RECEIVES annotations is stripped first.
80
+ * Stripping (rather than refusing) keeps the reader tolerant of documents that
81
+ * merely carry an unknown underscore key, while making the namespace
82
+ * unreachable from disk.
83
+ *
84
+ * `__proto__` starts with `_`, so a JSON document's own `__proto__` key is
85
+ * dropped here too rather than re-assigned through the inherited setter. */
86
+ /** A flat soul.yaml names its harness `harness:` (0.27.0) or, as released
87
+ * souls and capability-defined agents do (oats.aweb 1.13.1), `runtime:` —
88
+ * set both, read either until no released package writes `runtime`. Both,
89
+ * disagreeing, is refused. Returns the soul with `harness` only. */
90
+ export function soulHarnessField(soul, file) {
91
+ if (!soul || !Object.hasOwn(soul, "runtime")) return soul;
92
+ const { runtime, ...rest } = soul;
93
+ if (Object.hasOwn(soul, "harness") && soul.harness !== runtime) {
94
+ throw oatsError("E_BAD_MANIFEST", `${file} declares harness: ${soul.harness} and runtime: ${runtime}; \`runtime\` is the pre-0.27 name of \`harness\` — keep one`, { file, harness: soul.harness, runtime });
95
+ }
96
+ return { ...rest, harness: Object.hasOwn(soul, "harness") ? soul.harness : runtime };
97
+ }
98
+ export function stripInternalAnnotations(parsed) {
99
+ const out = {};
100
+ for (const key of Object.keys(parsed)) if (!key.startsWith("_")) out[key] = parsed[key];
101
+ return out;
102
+ }
103
+
104
+ // ---------- agents ----------
105
+ function soulOf(agentDir) { return join(agentDir, "soul"); }
106
+ function readSoul(agentDir, soulDir = soulOf(agentDir)) {
107
+ const p = join(soulDir, "soul.yaml");
108
+ if (!existsSync(p)) return undefined;
109
+ // Stripped before annotation: `_soulDir` is consumed as "the read-only soul
110
+ // inside a package" (spawn, roster) and `_dir` as the agent home, so a
111
+ // soul.yaml that could declare either would be describing itself to the
112
+ // kernel. See stripInternalAnnotations.
113
+ const text = readFileSync(p, "utf8");
114
+ const flat = withConfigFile(p, () => parseYamlFlat(text));
115
+ // A workspace-model soul.yaml (schemaVersion 2) nests maps (capabilities,
116
+ // knowledge …): the flat reader would turn them into "" and the version into a
117
+ // string. It is read with the real parser; a classic soul keeps the flat reader.
118
+ let parsed = flat;
119
+ if (flat.schemaVersion === "2") {
120
+ try { const v = parseConfigData(text, { format: "yaml" }).value; if (v && typeof v === "object" && !Array.isArray(v)) parsed = v; }
121
+ catch { /* unreadable as YAML: the flat view is what the classic readers saw */ }
122
+ }
123
+ const soul = soulHarnessField(stripInternalAnnotations(parsed), p);
124
+ soul._dir = agentDir;
125
+ // A package soul homes at <package>--<soul> (lib/workspace.mjs packageSoulAgentName): that
126
+ // directory, not the soul.yaml name, is its agent name, so its instances never share a
127
+ // member soul's name or roster row.
128
+ soul.name = basename(agentDir).includes("--") ? basename(agentDir) : (soul.name || basename(agentDir));
129
+ return soul;
130
+ }
131
+
132
+ export function listAgents(root) {
133
+ const agents = [];
134
+ const scan = (base, kind) => {
135
+ if (!existsSync(base)) return;
136
+ for (const e of readdirSync(base, { withFileTypes: true })) {
137
+ if (!e.isDirectory() || (kind === "persistent" && RESERVED.has(e.name))) continue;
138
+ const soul = readSoul(join(base, e.name));
139
+ if (soul) { soul.kind = soul.kind || kind; agents.push(soul); }
140
+ }
141
+ };
142
+ scan(root, "persistent");
143
+ return agents;
144
+ }
145
+
146
+ // Locate an instance home under an agents root, including capability-defined
147
+ // agents homing under <root>/<name>/ WITHOUT a soul there (listAgents cannot
148
+ // see those). Shared by retireInstance and `oats spawn --parent`.
149
+ // SECURITY: `name` is caller-controlled (CLI args, API bodies). It must be a
150
+ // plain instance name — reject path separators/dots up front, and verify the
151
+ // hit resolves to an IMMEDIATE child of an instances/ dir (realpath
152
+ // containment), or `oats retire ../../dev/soul` would existence-match and
153
+ // recursively delete a canonical soul.
154
+ const INSTANCE_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
155
+
156
+ /** ALL homes matching an instance name under one agents root. Spawn keeps names
157
+ * unique across the deployment since 0.26.0, but homes from earlier kernels (a
158
+ * generated-name collision like `dev --purpose foo-1` vs agent `dev-foo`) and
159
+ * direct kernel callers passing `instance` can still share one.
160
+ * Ambiguity-sensitive callers must use this, not first-match. Same
161
+ * containment/charset guarantees as findInstanceHome. */
162
+ export function findInstanceHomes(root, name) {
163
+ if (typeof name !== "string" || !INSTANCE_NAME_RE.test(name)) return [];
164
+ const contained = (agentDir) => {
165
+ const home = join(agentDir, "instances", name);
166
+ if (!existsSync(home)) return undefined;
167
+ try {
168
+ const real = realpathSync(home);
169
+ if (dirname(real) !== realpathSync(join(agentDir, "instances")) || basename(real) !== name) return undefined;
170
+ } catch { return undefined; }
171
+ return home;
172
+ };
173
+ const out = [];
174
+ const seen = new Set();
175
+ const push = (agent, home) => {
176
+ // Dedupe by canonical home so all-matches callers never see double hits.
177
+ let key; try { key = realpathSync(home); } catch { key = resolve(home); }
178
+ if (seen.has(key)) return;
179
+ seen.add(key);
180
+ out.push({ agent, home });
181
+ };
182
+ for (const a of listAgents(root)) {
183
+ const home = contained(a._dir);
184
+ if (home) push(a, home);
185
+ }
186
+ for (const { name: agentName, dir } of capabilityAgentDirs(root)) {
187
+ const home = contained(dir);
188
+ if (home) push({ name: agentName, kind: "capability", _dir: dir }, home);
189
+ }
190
+ return out;
191
+ }
192
+
193
+ /** The working directory as the shell names it: $PWD when it is the process's own directory, else
194
+ * the physical cwd. A path through a symlink (an attached instance's work/, which links into its
195
+ * owner's tree) then still belongs to the instance it was entered from. */
196
+ export function logicalCwd() {
197
+ const cwd = process.cwd(), pwd = process.env.PWD;
198
+ try { if (pwd && isAbsolute(pwd) && realpathSync(pwd) === realpathSync(cwd)) return pwd; } catch { /* a stale PWD */ }
199
+ return cwd;
200
+ }
201
+ /** The instance home enclosing `dir` (itself or its nearest such ancestor): a directory laid out
202
+ * as <agents-root>/<agent>/instances/<name> whose instance.json records `instance: <name>`.
203
+ * For a process whose harness strips the session env (Codex's shared app-server daemon runs
204
+ * tool commands outside the session); the caller validates the home as it does one named by
205
+ * OATS_INSTANCE_HOME. undefined when no such directory encloses `dir`. */
206
+ export function enclosingInstanceHome(dir) {
207
+ for (let d = resolve(dir); ; d = dirname(d)) {
208
+ if (basename(dirname(d)) === "instances" && INSTANCE_NAME_RE.test(basename(d))) {
209
+ try { if (JSON.parse(readFileSync(join(d, "instance.json"), "utf8"))?.instance === basename(d)) return d; }
210
+ catch { /* no readable instance.json: not a home */ }
211
+ }
212
+ if (dirname(d) === d) return undefined;
213
+ }
214
+ }
215
+
216
+ export { INSTANCE_NAME_RE, capabilityAgentDirs, readSoul, soulOf, yamlKey };
@@ -0,0 +1,30 @@
1
+ /** The word `oats status`, `oats status --server <id>` and `oats server roster` print for an instance
2
+ * row in text, and the way back they print under a row whose session was lost (#1617, #1628). Rows
3
+ * in, strings out: the row is a `status --json` instance row, this kernel's or a host's (the roster
4
+ * relays its `sessionEnd`), read as it is. A host on a kernel before `sessionEnd` (feature
5
+ * session-resume) sends none, and its rows read `idle` as before. The JSON is never changed here.
6
+ * Dependency-free. */
7
+ import { terminalText } from "./refused-text.mjs";
8
+ import { shellWord } from "./shell-word.mjs";
9
+ import { SESSION_END } from "./session-resume-contract.mjs";
10
+
11
+ const isLost = (i) => i.running === false && i.sessionEnd === SESSION_END.LOST;
12
+
13
+ /** `running` true is RUNNING; false is LOST when the session was lost (`sessionEnd: "lost"`, the
14
+ * judgement the resume sweep acts on), else idle (stopped, exited, never launched, or not said);
15
+ * null (a server that cannot be read, a Herdr home) is unknown, never idle. */
16
+ export const livenessWord = (i) => i.running === true ? "RUNNING" : i.running === false ? (isLost(i) ? "LOST" : "idle") : "unknown";
17
+
18
+ /** A row's word: a retire under way wins over its liveness. */
19
+ export const statusWord = (i) => i.retirePending ? "RETIRING" : livenessWord(i);
20
+
21
+ /** The one line under a LOST row that says how to bring it back, or null for any other row. Local:
22
+ * the resume by hand, or the next sweep. `host` (a `--server` or roster row): both refuse `--server`
23
+ * (E_BAD_ARGS), so the line says to run them on that host. */
24
+ export function lostLine(i, { host } = {}) {
25
+ if (i.retirePending || !isLost(i)) return null;
26
+ const start = typeof i.home === "string" && i.home ? `oats session start --resume --home ${shellWord(i.home)}` : null;
27
+ if (host !== undefined) return terminalText(`lost: on ${host}, run ${start ? `${start} there, or its next oats session resume` : "oats session resume there"}`);
28
+ const sweep = "the next oats session resume (run when OATS Desktop or oats tui opens)";
29
+ return terminalText(start ? `lost: ${start} brings it back; so does ${sweep} if it can vouch for the loss` : `lost: ${sweep} brings it back if it can vouch for the loss`);
30
+ }
@@ -0,0 +1,9 @@
1
+ /** The kernel's package root and version, read from package.json once at load. A leaf (awebai/oats#1630):
2
+ * `oats version` reads it without loading core.mjs, which re-exports both. Node built-ins only. */
3
+ import { readFileSync } from "node:fs";
4
+ import { join, dirname } from "node:path";
5
+ import { fileURLToPath } from "node:url";
6
+
7
+ /** Package root (this file lives in <pkg>/lib/). */
8
+ export const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
9
+ export const OATS_VERSION = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8")).version;
@@ -0,0 +1,28 @@
1
+ /** writeFileAtomic: a file written through a temporary sibling and renamed over it. A leaf
2
+ * (awebai/oats#1630): deployments.mjs writes this computer's list with it without loading packages.mjs
3
+ * and the remote reader, and packages.mjs re-exports it. Node built-ins only. */
4
+ import { mkdirSync, writeFileSync, rmSync, openSync, fchmodSync, closeSync, renameSync } from "node:fs";
5
+ import { dirname, join, basename } from "node:path";
6
+
7
+ /** Sibling temp + rename: replaces the directory entry itself, never writing
8
+ * THROUGH a pre-planted symlink at `file`. The new file's permission bits are the process's default
9
+ * (its umask) unless `mode` gives them: then they are exactly `mode`, and in force before a byte of
10
+ * `contents` is written, so a file kept private is never readable by others on the way. */
11
+ export function writeFileAtomic(file, contents, { mode } = {}) {
12
+ mkdirSync(dirname(file), { recursive: true });
13
+ const tmp = join(dirname(file), `.${basename(file)}.oats-tmp-${process.pid}`);
14
+ try {
15
+ if (mode === undefined) writeFileSync(tmp, contents);
16
+ else {
17
+ // A new file (one left by a killed process of this pid goes first; "wx" opens nothing that is
18
+ // there), created with no more than `mode` (the umask only takes bits away), then set to it exactly.
19
+ rmSync(tmp, { force: true });
20
+ const fd = openSync(tmp, "wx", mode);
21
+ try { fchmodSync(fd, mode); writeFileSync(fd, contents); } finally { closeSync(fd); }
22
+ }
23
+ renameSync(tmp, file);
24
+ } finally {
25
+ // A failed removal is not answered: when the write or the rename failed, that error is (#1076).
26
+ try { rmSync(tmp, { force: true }); } catch { /* the first error is the one answered */ }
27
+ }
28
+ }
@@ -3,12 +3,12 @@
3
3
  "packages": {
4
4
  "oats.okf": {
5
5
  "url": "https://github.com/awebai/oats-okf.git",
6
- "ref": "v5.5.0",
6
+ "ref": "v5.6.0",
7
7
  "path": "oats-package"
8
8
  },
9
9
  "oats.aweb": {
10
10
  "url": "https://github.com/awebai/oats-aweb.git",
11
- "ref": "v1.32.0",
11
+ "ref": "v1.32.1",
12
12
  "path": "oats-package"
13
13
  },
14
14
  "oats.jira": {
@@ -28,12 +28,12 @@
28
28
  },
29
29
  "oats.engineering": {
30
30
  "url": "https://github.com/awebai/oats-engineering.git",
31
- "ref": "v1.16.0",
31
+ "ref": "v1.17.2",
32
32
  "path": "oats-package"
33
33
  },
34
34
  "oats.cloning": {
35
35
  "url": "https://github.com/awebai/oats-cloning.git",
36
- "ref": "v1.0.1",
36
+ "ref": "v1.1.0",
37
37
  "path": "oats-package"
38
38
  },
39
39
  "oats.apps": {
@@ -48,7 +48,7 @@
48
48
  },
49
49
  "oats.framework": {
50
50
  "url": "https://github.com/awebai/oats.git",
51
- "ref": "oats-framework/v1.16.1",
51
+ "ref": "oats-framework/v1.16.3",
52
52
  "path": "oats-package"
53
53
  }
54
54
  },
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@awebai/oats",
3
- "version": "0.69.3",
3
+ "version": "0.69.5",
4
4
  "description": "OATS (Open Agent Team Specification) — durable souls, disposable instances, targetable capability packages, and the runtime-neutral oats CLI/kernel.",
5
5
  "keywords": [
6
6
  "agents",
@@ -83,7 +83,8 @@ const NO_CAPABILITIES = Object.freeze({ wanted: false, held: new Map(), selected
83
83
  * by the leader's Up or Down, and the leader cancelled by its own read) until the next key of any kind (the leader's: the key after it), one
84
84
  * typed to the agent included, or a resize (the loop's `{ passed }`). `notice`: such a line that came while no view that
85
85
  * draws one at every width was shown (the switcher, the help, a detail or a terminal with the
86
- * focus: see `drawsOutcome`), held until one is; or null.
86
+ * focus: see `drawsOutcome`), or while a line stood there, held until one is shown and the line
87
+ * has gone (`noticed`); or null.
87
88
  * It is the add of the deployment the run started in, refused.
88
89
  * `detachKey`: tui.json's `open.detachKey`, the leader (docs/tui.md, "The leader"; without one,
89
90
  * the default, C-x on every platform: config.mjs defaultDetachKey), and `leaderKey` the key id it is read as
@@ -799,10 +800,13 @@ function drawsOutcome(state) {
799
800
  return false;
800
801
  }
801
802
  /** A notice waiting for a view that draws the line under the sidebar's title (`notice`), made the
802
- * line there as soon as one is shown. */
803
+ * line there as soon as one is shown and no line stands there: a notice comes from what the run did
804
+ * by itself (the add of the deployment it started in), and never hides the answer to what the
805
+ * person did. It is said once that line has gone (the next key bound to an action; for a line of
806
+ * one key, the next key of any kind). */
803
807
  function noticed(step) {
804
808
  const s = step.state;
805
- if (s.notice === null || !drawsOutcome(s)) return step;
809
+ if (s.notice === null || s.outcome !== null || !drawsOutcome(s)) return step;
806
810
  return { ...step, state: next(s, { outcome: s.notice, notice: null }) };
807
811
  }
808
812
  /** A Remove asked stands only while its row is the switcher's selected choice: once the row is
@@ -350,8 +350,8 @@ name: acme
350
350
  members:
351
351
  - git:github.com/acme/acme-oats # the host is a member too
352
352
  packages:
353
- oats.framework: v1.16.1 # the installed CLI's catalog versions (below)
354
- oats.aweb: v1.32.0 # messaging, and tasks: agent identities, mail, chat and tasks
353
+ oats.framework: v1.16.3 # the installed CLI's catalog versions (below)
354
+ oats.aweb: v1.32.1 # messaging, and tasks: agent identities, mail, chat and tasks
355
355
  oats.machine: v0.1.1 # on a machine found-list only: the machine's steward
356
356
  defaults:
357
357
  capabilities:
@@ -365,7 +365,7 @@ defaultTeam: acme # every soul starts in this team
365
365
 
366
366
  - **The versions** are the installed CLI's catalog's:
367
367
  `"$(oats root)/package-catalog.json"`, `packages."oats.framework".ref`
368
- (for example `oats-framework/v1.16.1`: write the part after the `/`) and
368
+ (for example `oats-framework/v1.16.3`: write the part after the `/`) and
369
369
  `packages."oats.aweb".ref`, but never below `v1.31.0`: that release
370
370
  carries `oats.aweb-tasks`, and a bare version resolves through the
371
371
  catalog's tag convention even when the installed catalog names an older