@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.
- package/bin/oats.mjs +68 -49
- package/docs/configuration.md +12 -0
- package/docs/desktop-cli-api.md +8 -1
- package/docs/execution-targets.md +25 -3
- package/docs/implementation.md +42 -3
- package/docs/integrations.md +2 -2
- package/docs/knowledge.md +9 -6
- package/docs/named-test-runs.md +4 -2
- package/docs/official-catalog.md +6 -6
- package/docs/packages.md +14 -14
- package/docs/release-lane.md +25 -18
- package/docs/release-notes/v0.69.4.md +73 -0
- package/docs/release-notes/v0.69.5.md +146 -0
- package/docs/souls-and-instances.md +2 -2
- package/docs/tui.md +2 -1
- package/docs/upgrading.md +16 -5
- package/docs/workspaces.md +2 -2
- package/lib/agents-root.mjs +51 -0
- package/lib/automation-api.mjs +7 -0
- package/lib/automation-scope.mjs +35 -0
- package/lib/automations.mjs +2 -1
- package/lib/compile-cache.mjs +36 -0
- package/lib/core.mjs +39 -1348
- package/lib/deployment-path.mjs +127 -0
- package/lib/deployments.mjs +2 -2
- package/lib/drift.mjs +95 -0
- package/lib/hot-reads.mjs +131 -0
- package/lib/instance-address.mjs +21 -0
- package/lib/instance-lifecycle.mjs +4 -16
- package/lib/instance-listing.mjs +730 -0
- package/lib/instance-resolution.mjs +5 -166
- package/lib/materialize.mjs +2 -87
- package/lib/member-clone.mjs +188 -0
- package/lib/package-catalog.mjs +93 -0
- package/lib/packages.mjs +4 -24
- package/lib/reserved-launch-env.mjs +20 -0
- package/lib/resolved-deployment.mjs +1 -1
- package/lib/schedule.mjs +5 -29
- package/lib/semver.mjs +12 -0
- package/lib/servers.mjs +10 -12
- package/lib/session-end.mjs +3 -2
- package/lib/session-inspect.mjs +219 -0
- package/lib/soul-listing.mjs +216 -0
- package/lib/status-words.mjs +30 -0
- package/lib/version.mjs +9 -0
- package/lib/write-file-atomic.mjs +28 -0
- package/package-catalog.json +5 -5
- package/package.json +1 -1
- package/packages/tui/lib/store.mjs +7 -3
- 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
|
+
}
|
package/lib/version.mjs
ADDED
|
@@ -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
|
+
}
|
package/package-catalog.json
CHANGED
|
@@ -3,12 +3,12 @@
|
|
|
3
3
|
"packages": {
|
|
4
4
|
"oats.okf": {
|
|
5
5
|
"url": "https://github.com/awebai/oats-okf.git",
|
|
6
|
-
"ref": "v5.
|
|
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.
|
|
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.
|
|
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
|
|
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.
|
|
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
|
+
"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
|
|
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.
|
|
354
|
-
oats.aweb: v1.32.
|
|
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.
|
|
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
|