@awebai/oats 0.69.9 → 0.69.10

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/README.md CHANGED
@@ -39,7 +39,7 @@ If you are a person, give your coding agent (Claude Code, Codex, pi or any other
39
39
 
40
40
  - **Asks first, in one round:** your project, its repositories and where the workspace should live, the knowledge tools you use, and how your agents message each other ([aweb](https://aweb.ai) by default).
41
41
  - **Installs OATS, OATS Desktop and the messaging CLI.**
42
- - **Creates your workspace's team:** you sign in to your aweb account in your browser, and one command creates the team, owned by your account, that every agent you spawn joins.
42
+ - **Creates your workspace's team,** with no sign-in: the workspace's team, on an aweb account created for it, that every agent you spawn joins. You attach yourself to the account later in the setup, with the setup expert, or sign in to your own aweb account instead if you want the team on it from the start.
43
43
  - **Writes your workspace** in one commit, in your repository or a new private one: the workspace and its team, nothing else. Or it joins this machine to an existing workspace.
44
44
  - **Spawns the setup expert and opens the Desktop on it.** The setup expert is an OATS agent that turns OATS's defaults into your own coordination, knowledge and tasks capabilities, with you. You type only passwords, logins and tokens.
45
45
 
package/bin/oats.mjs CHANGED
@@ -3893,7 +3893,7 @@ async function capabilityCommand() {
3893
3893
  if (!hit) return NOT_DISPATCHED;
3894
3894
  // Without --soul the dispatch chose the soul (feature operator-default-soul): say which, on stderr,
3895
3895
  // so a provider's stdout (its --json envelope included) is untouched.
3896
- if (hit.defaultSoul) process.stderr.write(`oats ${cmd}: no --soul given; running as soul ${hit.defaultSoul}, the first soul of this deployment that provides "${cmd}" (pass --soul <name> to choose)\n`);
3896
+ if (hit.defaultSoul) process.stderr.write(`oats ${cmd}: using the settings and teams of soul ${hit.defaultSoul}, the first soul by name in this deployment that provides "${cmd}"; pass --soul <name> to use another\n`);
3897
3897
  // The same team/workspace facts a spawn hook receives (lead decision c3-7).
3898
3898
  const teamCtx = teamEnv(resolvedFromPrepared(hit.prepared, hit.deployment));
3899
3899
  // No home, so no recorded soul: OATS_SOUL is the soul's source at the resolved commit, read
@@ -74,9 +74,12 @@ A self-contained package has an `oats.json`:
74
74
  resolves as a spawn of a soul would: the soul named by `--soul <name>`, or,
75
75
  without `--soul`, the first soul of the deployment by name, not disabled
76
76
  there, whose resolution provides the namespace (souls whose resolution is
77
- refused are skipped). The chosen soul is named on stderr (`oats <namespace>:
78
- no --soul given; running as soul <member>/<soul>, …`), so the command's
79
- stdout, its `--json` envelope included, is the provider's alone. When no
77
+ refused are skipped). The chosen soul is named on stderr, so the command's
78
+ stdout, its `--json` envelope included, is the provider's alone:
79
+ `oats <namespace>: using the settings and teams of soul <member>/<soul>, …`.
80
+ The command runs with that soul's resolution (its provider settings, its
81
+ teams, its source and its name, in the variables below) and starts no
82
+ instance of it. When no
80
83
  soul provides the namespace, the command is refused with `E_BAD_ARGS` (`no
81
84
  soul of this deployment provides the <namespace> namespace; pass --soul
82
85
  <name>`, with any skipped souls and their codes in `details.skipped`).
@@ -57,7 +57,7 @@ refused (`E_WORKSPACE_SCHEMA`).
57
57
 
58
58
  | key | meaning |
59
59
  |---|---|
60
- | `workspace` | Repo ref of the workspace host (`git:host/org/repo`, `https://…`, `git@host:…`, `file:///…`, `/abs/bare.git`). Read with your own Git credentials; it need not be cloned. |
60
+ | `workspace` | Repo ref of the workspace host (`git:host/org/repo`, `https://…`, `git@host:…`, `ssh://<user>@<host>[:<port>]/…` with no password, `file:///…`, `/abs/bare.git`). Read with your own Git credentials; it need not be cloned. |
61
61
  | `standalone` | A repo ref to realize on its own: its souls and `from: here` capabilities plus `oats.core`, with no workspace lookup. For a repository whose workspace this machine cannot read ([workspaces.md](workspaces.md#the-standalone-case)). |
62
62
  | `clones` | `<repo key>: <absolute path>` for a member clone that is not at `<deployment>/<member name>/`. Only a soul whose work target needs a clone (`work: worktree \| checkout`) uses it. Lookup order: `spawn --repo`, then this map, then `<deployment>/<member name>` (a member named `agents` → `<deployment>/agents-repo`). None → `E_CLONE_MISSING`; a directory whose `origin` is another repository → `E_CLONE_MISMATCH`. |
63
63
  | `launchPromptAnswers` | Ignored, with a warning to remove it; a home entry `awebDevelopmentChannel: false` is refused. See [the development-channel confirmation](#the-development-channel-confirmation). |
@@ -130,7 +130,7 @@ see the [official catalog](official-catalog.md) for current pins.
130
130
  | `servers-per-workspace` | `workspaceKey` on registrations and `oats server list --json` rows; `oats server list --workspace-ref <ref>` and its `unknownWorkspace`; `workspaceKey` on `oats server check --json`, OATS 0.39.0 ([Servers per workspace](#servers-per-workspace)) | |
131
131
  | `server-connect` | `oats server connect`; `oats onboard --check`; `workspaceReadable` on `oats server check --json`, OATS 0.39.0 ([`oats server connect`](#oats-server-connect)) | |
132
132
  | `capability-route` | `oats <namespace> <command> … --server <id>` runs the capability command on the server, OATS 0.39.0 ([Capability commands on a server](#capability-commands-on-a-server)) | |
133
- | `operator-default-soul` | a capability command from a deployment without `--soul` runs as the first soul that provides its namespace (named on stderr); none is `E_BAD_ARGS`, OATS 0.39.0 ([capabilities.md](capabilities.md)) | |
133
+ | `operator-default-soul` | a capability command from a deployment without `--soul` resolves as the first soul that provides its namespace, using its settings and teams (named on stderr); none is `E_BAD_ARGS`, OATS 0.39.0 ([capabilities.md](capabilities.md)) | |
134
134
  | `waiting-on-you` | the `waiting` event kind and the session boundary rule; `oats instance waiting` and `oats instance attention`; `waitingOnYou` (with `message`) on `oats status --json` instance rows, on `oats session inspect --json` and in the events read, OATS 0.40.0 ([Waiting on you](#waiting-on-you)) | `eventsApi: 2` |
135
135
  | `automation-descriptions` | a `description` on every trigger and schedule row, local or workspace, by one rule; `oats schedule update <id> --description=<text>` (the description only) and `oats trigger update <id> --description=<text>`; `--description=<text>` on `schedule add` and `trigger add`, OATS 0.43.0 ([Shared row fields](#automations-shared-rows)) | |
136
136
  | `souls-capabilities` | `capabilities` on `oats souls --json` rows: the capabilities each soul composes, keyed like `oats capabilities` rows, with `from`, OATS 0.45.0 ([`oats capabilities` and `oats souls`](#oats-capabilities---dir---json--capabilitiesapi-1--oats-souls---dir---json--soulsapi-1)) | |
@@ -41,7 +41,7 @@ arrives from.
41
41
  # oats-workspace.yaml: one default per slot, for every soul
42
42
  packages:
43
43
  oats.okf: v5.7.0
44
- oats.aweb: v1.33.1
44
+ oats.aweb: v1.34.0
45
45
  oats.linear: v1.0.1
46
46
  oats.jira: v1.0.1
47
47
  defaults:
@@ -102,7 +102,12 @@ operations in full.
102
102
  provider in `capabilities:` (`oats.jira`, `oats.linear`) then holds two and
103
103
  fails with `E_SLOT_CONFLICT`: to keep its own, it adds
104
104
  `oats.aweb-tasks: off` to its `capabilities:`. A soul opts out of tasks
105
- entirely with `tasks: none`.
105
+ entirely with `tasks: none`. **A new workspace** made by the `oats-getting-started`
106
+ skill with aweb (not on a machine found-list) has it by default: the
107
+ skill writes this default (the team's first aweb task opts it in), unless
108
+ the person's projects
109
+ already use a tracker (GitHub issues in use, Jira, Linear and the like),
110
+ when it writes `tasks: none` and the setup expert connects the tracker.
106
111
  - **`oats.aweb`** mints a messaging identity for each instance at spawn and
107
112
  removes it at retire, contributes the aweb messaging skills, and wires the
108
113
  channel so sessions are woken by mail. Under `delivery: channel`, Claude Code
@@ -11,13 +11,13 @@
11
11
  "workspace": {
12
12
  "type": "string",
13
13
  "minLength": 1,
14
- "pattern": "^(?:git@[^@\\s]+|[^@\\s]+)$",
14
+ "pattern": "^(?:git@[^@\\s]+|ssh:/{2}[A-Za-z0-9._~][A-Za-z0-9._~-]*@[^@\\s]+|[^@\\s]+)$",
15
15
  "description": "Repo ref of the workspace host; observed over the remote, need not be cloned."
16
16
  },
17
17
  "standalone": {
18
18
  "type": "string",
19
19
  "minLength": 1,
20
- "pattern": "^(?:git@[^@\\s]+|[^@\\s]+)$",
20
+ "pattern": "^(?:git@[^@\\s]+|ssh:/{2}[A-Za-z0-9._~][A-Za-z0-9._~-]*@[^@\\s]+|[^@\\s]+)$",
21
21
  "description": "Repo ref to realize in the STANDALONE view: its own souls and from: here capabilities plus oats.core, no workspace lookup. Use when the repo's workspace cannot be read; `workspace:` still names the repo you point the kernel at."
22
22
  },
23
23
  "clones": {
@@ -11,7 +11,7 @@
11
11
  "workspace": {
12
12
  "type": "string",
13
13
  "minLength": 1,
14
- "pattern": "^(?:git@[^@\\s]+|[^@\\s]+)$",
14
+ "pattern": "^(?:git@[^@\\s]+|ssh:/{2}[A-Za-z0-9._~][A-Za-z0-9._~-]*@[^@\\s]+|[^@\\s]+)$",
15
15
  "description": "Repo ref of the workspace host, without revision."
16
16
  }
17
17
  }
@@ -72,12 +72,12 @@
72
72
  "memberRef": {
73
73
  "type": "string",
74
74
  "minLength": 1,
75
- "pattern": "^(?:git@[^@\\s]+|[^@\\s]+)$",
76
- "description": "A repo ref (git:<host>/<path>, https://…, git@host:path.git, file:///…) with NO @revision."
75
+ "pattern": "^(?:git@[^@\\s]+|ssh:/{2}[A-Za-z0-9._~][A-Za-z0-9._~-]*@[^@\\s]+|[^@\\s]+)$",
76
+ "description": "A repo ref (git:<host>/<path>, https://…, git@host:path.git, ssh://<user>@<host>[:<port>]/<path> with no password, file:///…) with NO @revision."
77
77
  },
78
78
  "pinnedRef": {
79
79
  "type": "string",
80
- "pattern": "^(?:git@[^@\\s]+|[^@\\s]+)@[0-9a-f]{40}$",
80
+ "pattern": "^(?:git@[^@\\s]+|ssh:/{2}[A-Za-z0-9._~][A-Za-z0-9._~-]*@[^@\\s]+|[^@\\s]+)@[0-9a-f]{40}$",
81
81
  "description": "<repo ref>@<full 40-hex commit OID>."
82
82
  },
83
83
  "repoKey": {
@@ -9,9 +9,9 @@ or workspace membership alone does not make a package official.
9
9
 
10
10
  | package | release | capabilities | package souls |
11
11
  |---|---|---|---|
12
- | `oats.framework` | `oats-framework/v1.19.0` (this repository) | `oats.core`, `oats.setup`, `oats.onboarding`, `oats.support`, `oats.knowledge-theory` | `knowledge-theory-expert`, `oats-setup-expert` |
12
+ | `oats.framework` | `oats-framework/v1.20.0` (this repository) | `oats.core`, `oats.setup`, `oats.onboarding`, `oats.support`, `oats.knowledge-theory` | `knowledge-theory-expert`, `oats-setup-expert` |
13
13
  | `oats.okf` | `v5.7.0` | `oats.okf` (knowledge), `oats.okf-harvest`, `oats.okf-maintenance` | `knowledge-harvester`, `knowledge-maintainer` |
14
- | `oats.aweb` | `v1.33.1` | `oats.aweb` (messaging), `oats.aweb-tasks` (tasks) | |
14
+ | `oats.aweb` | `v1.34.0` | `oats.aweb` (messaging), `oats.aweb-tasks` (tasks) | |
15
15
  | `oats.engineering` | `v1.18.0` | `oats.engineering-expert`, `oats.developer`, `oats.code-review`, `oats.maintainer` | `code-reviewer` |
16
16
  | `oats.authoring` | `v1.0.3` | `oats.authoring` | |
17
17
  | `oats.cloning` | `v1.1.0` | `oats.cloning` | `cloner` |
package/docs/packages.md CHANGED
@@ -51,7 +51,7 @@ packages:
51
51
  - **Bare version** (`v5.7.0`, `5.7.0`, `1.0.0-rc.1`): the id is looked up in
52
52
  the official catalog — `package-catalog.json` in the `oats` repo, or the file
53
53
  named by `OATS_PACKAGE_CATALOG` — which supplies the repo url, the tag
54
- convention (`v5.7.0` or `oats-framework/v1.19.0`) and the payload path. An id
54
+ convention (`v5.7.0` or `oats-framework/v1.20.0`) and the payload path. An id
55
55
  the catalog does not know is `E_PACKAGE_MISSING` ("use `git:<repo>@<ref>` for
56
56
  a package outside the catalog"). The catalog is the reviewed official list
57
57
  ([official-catalog.md](official-catalog.md)) and the only way a
@@ -74,9 +74,9 @@ members:
74
74
  - git:github.com/acme/agents
75
75
  - git:github.com/acme/platform
76
76
  packages:
77
- oats.framework: v1.19.0
77
+ oats.framework: v1.20.0
78
78
  oats.okf: v5.7.0
79
- oats.aweb: v1.33.1
79
+ oats.aweb: v1.34.0
80
80
  teams:
81
81
  platform: { team: "platform:acme.aweb.ai", description: Platform engineering }
82
82
  defaults:
@@ -134,7 +134,7 @@ Declaring a package in the workspace's `packages:` is the trust decision
134
134
  ## `oats package add | remove`
135
135
 
136
136
  ```bash
137
- oats package add oats.aweb v1.33.1 # a catalog version
137
+ oats package add oats.aweb v1.34.0 # a catalog version
138
138
  oats package add acme.tools git:github.com/acme/tools@v0.4.0
139
139
  oats package remove acme.tools
140
140
  ```
@@ -353,11 +353,11 @@ A soul that names one of the package's capabilities with
353
353
  "policy": "docs/official-catalog.md",
354
354
  "packages": {
355
355
  "oats.okf": { "url": "https://github.com/awebai/oats-okf.git", "ref": "v5.7.0", "path": "oats-package" },
356
- "oats.framework": { "url": "https://github.com/awebai/oats.git", "ref": "oats-framework/v1.19.0", "path": "oats-package" }
356
+ "oats.framework": { "url": "https://github.com/awebai/oats.git", "ref": "oats-framework/v1.20.0", "path": "oats-package" }
357
357
  }
358
358
  }
359
359
  ```
360
360
 
361
- `ref` carries the tag convention: a workspace's `oats.framework: v1.19.0`
362
- resolves to tag `oats-framework/v1.19.0`. Resolving through the catalog never
361
+ `ref` carries the tag convention: a workspace's `oats.framework: v1.20.0`
362
+ resolves to tag `oats-framework/v1.20.0`. Resolving through the catalog never
363
363
  advances a lock by itself: `oats sync` does, and says so.
@@ -0,0 +1,66 @@
1
+ # OATS 0.69.10
2
+
3
+ 0.69.10 moves the official catalog to `oats.framework` 1.20.0 (the setup
4
+ expert talks to a newcomer in everyday words, and puts a local-only project on
5
+ GitHub on the person's yes) and `oats.aweb` 1.34.0 (messaging only: aweb tasks
6
+ are taught only where `oats.aweb-tasks` is composed; tested with aw 1.36.53).
7
+ Getting started now sets up a new workspace with no aweb sign-in, and gives its
8
+ agents aweb's task list unless they already use a tracker. A repository
9
+ reference may now be an `ssh://` address with a user. A local schedule accepts
10
+ any soul the workspace offers.
11
+
12
+ ## Upgrade
13
+
14
+ - **Either order of the Desktop and the CLI works.**
15
+ [Upgrading](../upgrading.md) installs the Desktop first, and a host that
16
+ installed the CLI first is fine too: the 0.69.10 Desktop accepts OATS CLIs
17
+ `>=0.26.0 <0.70.0`, and so do the 0.69.9 and 0.69.8 Desktops.
18
+ - **Package moves:** the official catalog pins oats.framework 1.20.0 and
19
+ oats.aweb 1.34.0, with no change to their OATS floors (oats.aweb keeps aw
20
+ >=1.36.33, and is tested with 1.36.53). A deployment takes each by raising
21
+ its own pin (`/oats-package-pins`), then `oats sync`. Running instances keep
22
+ the modules they were spawned with: new spawns get the new ones, and a
23
+ stopped home moves with `oats instance upgrade`.
24
+ - **With oats.aweb 1.34.0, aweb tasks come only from `oats.aweb-tasks`.**
25
+ oats.aweb no longer mentions task coordination in anything it puts into a
26
+ home. A deployment that uses aweb tasks composes `oats.aweb-tasks` (for
27
+ example `defaults: { tasks: { oats.aweb-tasks: { from: package } } }`);
28
+ without it, its agents get no task guidance after the upgrade. The rule that
29
+ `aw lock` and `aw roles` stay outside OATS moves with it.
30
+ - **An `ssh://user@host/...` repository reference is refused by older
31
+ kernels.** Before any member uses the form in a shared `oats-workspace.yaml`,
32
+ upgrade every deployment of that workspace to 0.69.10: an older kernel
33
+ refuses the file.
34
+
35
+ ## Changed
36
+
37
+ - **`oats.framework` 1.20.0 ships the setup expert's newcomer changes.** `oats.setup` 2.11.0's `/oats-setup-expert` talks to a newcomer in everyday words, and puts a project that lives only on the person's computer on GitHub when they say yes, after checking for secrets and for files GitHub refuses (#1710, #1711, #1712). `oats.onboarding` 1.1.1's `/oats-tailor-workspace` uses the same plain words, and keeps the tasks default a new workspace was given rather than adding a second tasks provider (#1710, #1716). No command they name needs a newer OATS than each capability already admits ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
38
+ - **`oats.aweb` 1.34.0: messaging only; aweb tasks by opt-in.** Nothing oats.aweb puts into a home names the task layer, `aw task`, `aw work`, `aw lock`, `aw roles` or task claims: not the inject, not the `Comms:` line, not its skills. `oats.aweb-tasks` teaches them, and its inject and skill open with the workspace's opt-in. The inject gives the whole messaging loop for mail and chat ([awebai/oats-aweb#186](https://github.com/awebai/oats-aweb/pull/186)).
39
+ - **`oats.aweb` 1.33.3: tested with aw 1.36.53.** `AW_TESTED` moves to 1.36.53, npm's `latest` now that aweb Cloud serves invite preview; the floor stays 1.36.33. A resident create whose API key is refused can be rerun under aw 1.36.53. The unread-count readiness warning follows whether health publishes now, inside readiness's time budget, and the alias-conflict refusal names its remedy without a ticket or kernel version ([awebai/oats-aweb#179](https://github.com/awebai/oats-aweb/pull/179), [#182](https://github.com/awebai/oats-aweb/pull/182), [#184](https://github.com/awebai/oats-aweb/pull/184)).
40
+ - **The setup expert talks to a newcomer in everyday words.** `oats.framework`'s `/oats-setup-expert` and `/oats-tailor-workspace` assume the person may not know what a repository, Git or a terminal is. They ask about the person's project, their code on GitHub and the group their agents talk in, each question with a recommended default, and avoid OATS's and Git's own words. A command, a change or a link is shown only where the person must act on it, introduced in a plain sentence; the setup briefing's rules on what the person types and on showing a change before a push come first. A newcomer test run found the setup expert's first question saying "agents can only work in a repository the workspace lists as a member" ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
41
+ - **The setup expert puts a project that lives only on the person's computer on GitHub, on their yes.** OATS reads a workspace's members over Git, so `/oats-setup-expert` step 3 now first handles a folder whose code is on no GitHub repository. A folder inside a repository that is already on GitHub is not copied: the person is asked whether that repository is the project to add. Before asking, it finds what would be pushed without changing the folder:
42
+ - for a new repository, the files Git would take, without dependency and build folders or files too large for GitHub;
43
+ - for a repository with commits, its current branch and its history, with its whole history searched for secrets.
44
+
45
+ Files named like a secret or holding a private key are certain: left out of a new repository, and a reason not to push one whose history holds them. Other files whose content may hold a password or key are shown to the person by name, and they choose. The scans print file names only, never a secret's value. It shows the person the files, what it leaves out, and whether the project's own automations would start. It then proposes a private repository under their GitHub login, named after the folder. A new repository is created with the secrets left out and the staged files checked against what was shown. Where a secret is in a repository's history, nothing is pushed: the person chooses a fresh copy or keeping it local. On a no it creates nothing and says the agents can't work on that project until its code is on GitHub. A newcomer test run found the setup expert improvising this step ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
46
+ - **The local-only project step cleans up and checks a repository's history for files GitHub refuses.** `/oats-setup-expert` step 3's previews now remove their temporary scratch repository. For a repository with commits, it lists by name any file over 100 MiB in its branch's history, since GitHub refuses that push, and then pushes nothing and offers a fresh copy of the current files or keeping the project local ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
47
+ - **Getting started speaks to a newcomer and asks less.** These changes come from newcomer test runs of `oats-getting-started` on fresh machines.
48
+ - **Wording:** the skill talks in everyday words (projects, code, folders, "the setup assistant") and keeps file paths, commands, error codes and raw output to itself.
49
+ - **Step 1** first runs step 2's read-only checks, then asks three things: what the agents should help with, which projects, and whether this is a fresh start or joining someone's setup. It proposes everything else as defaults: the name (from the project's), where the shared setup lives and under which GitHub owner (from the project's repositories or the login), the messaging account, the folder where the agents live (default `<home>/Agents/<workspace>`) and the Desktop. It doesn't ask for the harness. When an answer changes a default, the skill derives them again and shows the final values.
50
+ - **One confirmation covers every change to the person's computer** that the checks found needed: the installs, the PATH line, the Claude channel plugin, folder trust, the Desktop and any missing system package. The list names each change by what and where, Git's own settings included. A new private GitHub repository for a new workspace goes on the same list, and so does the name on the first commit when Git has none, so neither is asked again later. The skill never runs `sudo` for anything outside that list. When the agent's own permission check refuses a step, the skill never runs it another way: it asks the person once, by name, retries once, and otherwise says what is missing. The person never types a command with `!`, and types one in a terminal only for a password or login when no window can be opened for them.
51
+ - **The Desktop downloads in the background** right after the GitHub login, with its checksum and attestation, while the CLI installs. It is installed only once all three have passed.
52
+ - **Linux:** the Desktop's system libraries are checked before the install. A missing ALSA is a system package to confirm; a missing FUSE 2 installs nothing, and the Desktop starts with `--appimage-extract-and-run`.
53
+ - **Minimums:** a new workspace needs `oats.framework` 1.19.0 or later, whose setup expert attaches the person to the workspace's messaging account (1.18.0 before), and its `oats.aweb` pin is never below 1.33.1, the release whose invite works after a no-sign-in setup.
54
+ - **An existing workspace** names its setup expert and the machine's messaging root after the machine's short hostname, with a suffix hashed from the machine's id (never the id itself) for hostnames many machines share. From `oats.aweb` 1.33.1 the invite answer's `awebUrl` is the service URL the join needs; without it the join takes the service from the invite, and stops if it can't.
55
+ - **The hand-off** tells the person to switch to the Desktop and click the setup assistant, since it has already started and will ask them its first question there. Attaching the person to the workspace's messaging account happens later in the setup, with the setup expert ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
56
+ - **Getting started creates a new workspace's aweb account and team with no sign-in.** By default, `oats-getting-started` no longer asks the person to sign in to aweb in their browser. Step 1 names the account `N` (default `<workspace>-oats`) and its root `A` (`<workspace>-root`). The skeleton's team is `default:N.aweb.ai`. Step 9 creates the account and team with `oats aweb setup --soul S --username N --name A --label L`, plan first, and goes on only when the answer's `result.team` equals that line and `result.membershipVerified` is true. When `N` is taken, the person picks another, the team line is changed, committed and synced, and the signup runs again. The person is told the team is on an aweb account created for the workspace, which they attach themselves to later in the setup, with the setup expert (`/oats-tailor-workspace`). Signing in with `aw auth login` and `aw team ensure`, for a team owned by their own aweb account from the start, is now the optional step 5 ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
57
+ - **Getting started: a new workspace's agents track work in aweb's task list by default, unless the person already uses a tracker.** With aweb, `oats-getting-started` now writes `tasks: { oats.aweb-tasks: { from: package } }` into a new workspace's `defaults`. It writes `tasks: none` when the person's projects already use a tracker, and the setup expert then connects that tracker with them. The skill finds a tracker rather than asking about one: a GitHub repository with an issue updated in the last 180 days and not opened by a bot (issues switched on but unused don't count), a tracker the person names, or ticket keys such as `ABC-123` in recent branch names or commit subjects. It asks one prefilled question only when unsure: ticket keys the person didn't name, a project kept somewhere other than GitHub, or an issues check that failed. The setup expert's tailor skill keeps that default rather than adding a second tasks provider. The hand-off names the choice and how to change it, and with a tracker asks the person to leave aweb's task list empty, because one task there opts the whole team in ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
58
+ - **Getting started: pi's aweb extension comes without its skills.** After `pi install npm:@awebai/pi`, `oats-getting-started` sets the extension's entry in pi's `settings.json` to `"skills": []`, so OATS's install puts no machine-wide aweb skills on the computer; each agent gets its skills from its own capabilities ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
59
+ - **An `ssh://` reference with a user is accepted wherever a repository reference is.** `oats-local.yaml` (`workspace`, `standalone`), `oats-membership.yaml` (`workspace`) and `oats-workspace.yaml` (`members`, `stores` and an external soul's pinned `source`) now accept `ssh://<user>@<host>[:<port>]/<path>`, with a user of letters, digits and `. _ ~ -` that doesn't start with `-`, the way the kernel already read it and the way `git@host:path` always was. Before, `oats onboard --workspace ssh://user@host/path` was refused with `E_WORKSPACE_SCHEMA`, while the refusal showed the reference without its user, so it looked valid. A password (`ssh://user:password@…`, percent-encoded or not), an empty user and a second `@` in the host or path stay refused, so in a pinned source the last `@` is always the pin. A package's `git:` reference keeps its own grammar. Existing files need no change ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
60
+ - **An operator command run without `--soul` says what the chosen soul is for.** `oats <namespace>` from a deployment directory, with no `--soul`, now prints `oats <namespace>: using the settings and teams of soul <member>/<soul>, the first soul by name in this deployment that provides "<namespace>"; pass --soul <name> to use another` on stderr, in place of `no --soul given; running as soul …`. Which soul is chosen is unchanged ([operator commands](../capabilities.md)). The old line read as if an unrelated soul were acting: a newcomer test run on a fresh workspace saw `oats aweb` say it was "running as" the knowledge-theory expert ([awebai/oats#1665](https://github.com/awebai/oats/issues/1665)).
61
+
62
+ ## Fixed
63
+
64
+ - **A local spawn schedule accepts any soul the workspace offers.** `oats schedule add` and `update` refused a local spawn job whose `agent` is a member or package soul this deployment had never spawned (`agent: no soul named "<soul>" under <root>/agents`, `E_SCHEDULE_INVALID`), although `oats spawn` resolves it, and a run always resolves its soul as `oats spawn` does. Such a job is now checked by `oats spawn <agent> --preview` with the job's own `launchConfig`, `harness`, `model`, `backend` and `repo`: a job whose preview fails is still refused with `E_SCHEDULE_INVALID`, field `agent`, now carrying spawn's own message and its code in `details.code`; a soul already spawned here is accepted without the preview, as before. `oats schedule test` reports such a soul as resolving (and now passes the job's `repo` to its preview), and the job runs at its due minutes and through `run-now` ([Kinds](../schedules.md#kinds)).
65
+ - **`oats schedule reconcile` keeps a spawn attempt it cannot attribute.** When a spawn job's result was never recorded and its `agent` is a qualified or package soul, whose runs spawn names after the soul's stem, reconcile no longer takes the missing `<agent>-<purpose>-<minute>` home as proof that nothing launched: it answers `unknown` and keeps the attempt and its slot until you check by hand and run `reconcile <id> --clear`. Before, it recorded `launch-failed` and freed the slot while the run's instance could still be running. A local or workspace job whose `agent` is a member soul under `agents/` is reconciled as before ([What a run reports](../schedules.md#what-a-run-reports)).
66
+ - **Getting started: the steward's global address names the oats.aweb release that carries its route.** On a machine found-list, the skill gated the steward's global address on oats.aweb 1.34.0, which ships without the resident root route; it now names 1.35.0. On 1.34.0 the plan already fell back to a local team identity, so only the stated version changes.
package/docs/schedules.md CHANGED
@@ -75,16 +75,25 @@ refuses the key on a trigger.
75
75
  - **spawn** `{…, agent, agentsRoot?, repo?, backend?, purpose?, task,
76
76
  launchConfig?, harness?, model?, yolo?, wake?}` — every due minute launches
77
77
  one disposable instance of `agent` with the options `oats spawn` takes.
78
- `agentsRoot`, when given, must be the deployment's `agents/` root; `repo`
78
+ `agent` is resolved as `oats spawn <agent>` resolves it (a member or
79
+ package soul the workspace offers, see `oats souls`), whether or not this
80
+ deployment has spawned it before. `add` and `update` refuse a job whose
81
+ `oats spawn <agent> --preview`, with the job's `launchConfig`, `harness`,
82
+ `model`, `backend` and `repo`, fails (`E_SCHEDULE_INVALID`, field `agent`,
83
+ with spawn's own message and its code in `details.code`), or whose preview
84
+ answer cannot be confirmed; a soul this deployment has already spawned is
85
+ accepted without the preview. `agentsRoot`, when given, must be the deployment's `agents/` root; `repo`
79
86
  is the work repository, as `--repo`. `backend` is `tmux`; `backend: herdr`
80
87
  is refused (`E_HERDR_REMOVED`, naming the file and key: Herdr was removed in
81
88
  0.31.0), and a stored job that names it is reported invalid and never runs.
82
89
  `model` is a model id (a letter or
83
90
  digit, then letters, digits and `. _ : / @ + - [ ]`, at most 128
84
91
  characters) or `@native-default`; `agent` and `repo` never start with `-`,
85
- so no value can be read as an option of the child `oats spawn`. Each run is
86
- named `<agent>-<purpose or id>-<YYYYMMDDHHMM>`, at most 64 characters (a
87
- longer one is refused when saved, `E_SCHEDULE_INVALID`). The task gets a
92
+ so no value can be read as an option of the child `oats spawn`. Spawn names
93
+ each run after the soul's stem, `<stem>-<purpose or id>-<YYYYMMDDHHMM>`: the
94
+ stem is the soul's name, `<package>-<soul>` for a package soul. Instance
95
+ names are at most 64 characters; a job whose `<agent>-<purpose or
96
+ id>-<YYYYMMDDHHMM>` is longer is refused when saved (`E_SCHEDULE_INVALID`). The task gets a
88
97
  trailing block naming the job and the minute and ending with `oats retire
89
98
  --self`. `wake` (`{cron, tz, message}`) attaches a wake schedule to each
90
99
  launched instance.
@@ -771,7 +780,12 @@ exited, or its tmux server is gone), so its due minutes are skipped with
771
780
  `previous instance stopped: retire it (oats retire <instance>) or start it
772
781
  again (oats session start --home <home>)`, and
773
782
  `oats schedule run-now` refuses with the same words (`E_SCHEDULE_RUNNING`).
774
- While the instance runs, they are skipped as `still running`. After a reboot, a wake job
783
+ While a spawn, command or operation job's run is live, `oats schedule run-now`
784
+ refuses with `schedule <id> is still running` (`E_SCHEDULE_RUNNING`) and its
785
+ due minutes are skipped as `still running`: a job runs once at a time, never
786
+ overlapping its own run, and a skipped minute is not queued. A wake job is not
787
+ held this way: delivering to a running home takes no slot (see **Slots**
788
+ below). After a reboot, a wake job
775
789
  starts its instance's session at its next due minute, and a spawn job shows
776
790
  `stopped` with the command to retire or start its instance.
777
791
 
@@ -780,7 +794,12 @@ or answered no envelope, or an attempt was never recorded. A job with a
780
794
  persisted attempt is skipped until `oats schedule reconcile <id>` (an
781
795
  unknown `lastRun` alone does not block it; see below), which adopts only an attributable
782
796
  receipt (a spawn job's instance, named for its minute, or the instance a
783
- command's answer named). When nothing is attributable, check the roster and
797
+ command's answer named). A spawn job's instance is found by the name
798
+ `<agent>-<purpose or id>-<YYYYMMDDHHMM>`, and no home of that name proves the
799
+ attempt launched nothing only when `agent` is the bare name of a member soul
800
+ under `agents/`. For a qualified or package soul, whose runs spawn names after
801
+ its stem, reconcile answers `unknown` and keeps the attempt and its slot. When
802
+ nothing is attributable, check the roster and
784
803
  the host by hand, then `reconcile <id> --clear` records `launch-failed` and
785
804
  frees the slot. The unresolved attempt shows in `show` as `attempt:
786
805
  {scheduledFor, startedAt, error?, exited?, exitStatus?, exitSignal?}`;
package/docs/upgrading.md CHANGED
@@ -6,11 +6,11 @@ host that comes from it.
6
6
 
7
7
  ## Upgrading to the latest version
8
8
 
9
- The latest version is **OATS 0.69.9** ([release notes](release-notes/v0.69.9.md)).
10
- The 0.69.9 Desktop accepts OATS CLIs `>=0.26.0 <0.70.0`.
9
+ The latest version is **OATS 0.69.10** ([release notes](release-notes/v0.69.10.md)).
10
+ The 0.69.10 Desktop accepts OATS CLIs `>=0.26.0 <0.70.0`.
11
11
 
12
12
  **First, read the `## Upgrade` section of every release after yours, up to
13
- 0.69.9,** in the [release notes](release-notes/): it says what to do before
13
+ 0.69.10,** in the [release notes](release-notes/): it says what to do before
14
14
  the CLI changes, and what else must change with it (the Desktop, another
15
15
  tool, a package pin). [Coming from an older version](#coming-from-an-older-version)
16
16
  names the releases that ask for more than the steps below. `oats version`
@@ -19,8 +19,8 @@ prints the version you have.
19
19
  Then, on each host:
20
20
 
21
21
  ```sh
22
- # 0. where the Desktop is installed: Desktop 0.69.9 first
23
- npm install -g @awebai/oats@0.69.9 # 1. the CLI
22
+ # 0. where the Desktop is installed: Desktop 0.69.10 first
23
+ npm install -g @awebai/oats@0.69.10 # 1. the CLI
24
24
  oats update # 2. in each deployment: the plan, then it asks before it runs
25
25
  oats doctor # 3. in the same deployment
26
26
  ```
@@ -202,6 +202,11 @@ of the Desktop and the CLI, and an optional package pin. A change a script
202
202
  must follow is in its release's Upgrade section whether or not it is listed
203
203
  here.
204
204
 
205
+ - **[0.69.10](release-notes/v0.69.10.md#upgrade):** the catalog pins
206
+ oats.framework 1.20.0 and oats.aweb 1.34.0. With oats.aweb 1.34.0, a
207
+ deployment that uses aweb tasks composes `oats.aweb-tasks`. Upgrade every
208
+ deployment of a workspace before its shared `oats-workspace.yaml` uses an
209
+ `ssh://user@host/...` reference.
205
210
  - **[0.69.9](release-notes/v0.69.9.md#upgrade):** the catalog pins
206
211
  oats.framework 1.19.0, oats.aweb 1.33.1 and oats.engineering 1.18.0. With
207
212
  oats.engineering 1.18.0, a stop doesn't hold while a checkpoint is pending:
@@ -54,7 +54,7 @@ members: # repo refs, NO @revision (E_WORKSPAC
54
54
  - git:github.com/acme/tools # a member that ALSO publishes a package (see below)
55
55
 
56
56
  packages: # the ONLY versioned things
57
- oats.framework: v1.19.0 # bare version → resolves through the official catalog
57
+ oats.framework: v1.20.0 # bare version → resolves through the official catalog
58
58
  oats.okf: v5.7.0
59
59
  acme.tools: git:github.com/acme/tools@v0.4.0 # outside the catalog → git:<repo>@<tag|OID>; still a package
60
60
 
@@ -121,7 +121,7 @@ export function soulCandidates(discovery) {
121
121
  }
122
122
  for (const x of discovery.external || []) {
123
123
  if (!x.soul?.name) continue;
124
- const repoKey = x.soul.repoKey ?? parseRepoRef(x.source.replace(/@.*$/, "")).key;
124
+ const repoKey = x.soul.repoKey ?? parseRepoRef(x.source.replace(/@[0-9a-f]{40}$/, "")).key;
125
125
  out.push({
126
126
  entry: { ...x.soul, repoKey, commit: x.commit, external: true },
127
127
  matches: (name) => { const [repoPart, soulPart] = splitSoulName(name); return x.soul.name === soulPart && (!repoPart || sameRepo(repoKey, repoPart) || (x.source && String(x.source).includes(repoPart))); },
package/lib/schedule.mjs CHANGED
@@ -341,7 +341,7 @@ function storedHerdrBackend(ws, id, def) {
341
341
 
342
342
  /** Validate and normalize one definition against its scope. `backendSource` names the file and key
343
343
  * a definition read from elsewhere sets its backend in (default: this scope's definitions file). */
344
- export function validateDefinition(ws, def, { checkAgent = true, backendSource } = {}) {
344
+ export function validateDefinition(ws, def, { checkAgent = true, backendSource, io } = {}) {
345
345
  if (!def || typeof def !== "object" || Array.isArray(def)) throw scheduleError("E_SCHEDULE_INVALID", "definition must be an object", { field: "definition" });
346
346
  if (def.kind === "trigger") throw scheduleError("E_SCHEDULE_INVALID", "kind: a trigger is added with `oats trigger add`, not `oats schedule add`", { field: "kind" });
347
347
  const id = def.id;
@@ -385,7 +385,7 @@ export function validateDefinition(ws, def, { checkAgent = true, backendSource }
385
385
  validateCron(w.cron, w.tz, "wake.cron"); validateMessage(w.message, "wake.message");
386
386
  out.wake = { cron: w.cron.trim(), tz: w.tz.trim(), message: w.message };
387
387
  }
388
- if (checkAgent) resolveScheduledAgent(ws, out);
388
+ if (checkAgent) confirmScheduledSoul(ws, out, io);
389
389
  } else if (def.kind === "command") {
390
390
  if (typeof def.cwd !== "string" || !isAbsolute(def.cwd) || !inside(ws, def.cwd) || !existsSync(def.cwd)) throw scheduleError("E_SCHEDULE_INVALID", "cwd: an existing absolute directory inside the scope", { field: "cwd" });
391
391
  if (!Array.isArray(def.argv) || !def.argv.length || def.argv.some((a) => typeof a !== "string" || a.includes("\0")) || def.argv[0] !== "oats") throw scheduleError("E_SCHEDULE_INVALID", "argv: oats-only argument list starting with \"oats\"", { field: "argv" });
@@ -468,16 +468,31 @@ export function validateWorkspaceSchedule(dep, a) {
468
468
 
469
469
  /** The soul a spawn job launches, under the deployment's one agents root
470
470
  * (a definition's agentsRoot, when given, must be that root). `repo` is the
471
- * work repository and never selects a soul. */
471
+ * work repository and never selects a soul. Every spawn job names its soul as
472
+ * `oats spawn <soul>` does: the spawn resolves it through discovery (a member or
473
+ * package soul), whether or not this deployment has spawned it before; the
474
+ * agents/<soul>/soul copy is only spawn's per-commit cache. A local job still
475
+ * passes --agents-root (spawn checks it is its root). */
472
476
  export function resolveScheduledAgent(ws, def) {
473
477
  const [root] = scopeRoots(ws);
474
- // A workspace schedule (0.29.0) names its soul as `oats spawn <soul>` does: discovery resolves
475
- // it (a member or package soul), whether or not this deployment has spawned it before.
476
478
  if (def.workspace) return { root, agent: { name: def.agent }, discover: true };
477
479
  if (def.agentsRoot && resolve(def.agentsRoot) !== root) throw scheduleError("E_SCHEDULE_INVALID", `agentsRoot: ${def.agentsRoot} is not this deployment's agents root (${root})`, { field: "agentsRoot" });
478
- const agent = findAgent(root, def.agent);
479
- if (!agent) throw scheduleError("E_SCHEDULE_INVALID", `agent: no soul named ${JSON.stringify(def.agent)} under ${root}`, { field: "agent" });
480
- return { root, agent };
480
+ return { root, agent: { name: def.agent } };
481
+ }
482
+ /** The save-time check of a local spawn job's soul (`add`, `update`): refuse what `oats spawn`
483
+ * would refuse. A soul already under the agents root is accepted without a child, so offline
484
+ * adds and stale cached souls stay accepted; any other name goes through spawn's own preview,
485
+ * with the job's selectors (a selector the run needs, such as its repo, would otherwise fail
486
+ * the preview's checks). */
487
+ function confirmScheduledSoul(ws, def, io) {
488
+ const { root, discover } = resolveScheduledAgent(ws, def);
489
+ if (findAgent(root, def.agent)) return;
490
+ try { spawnPreview(ws, def, { root, discover }, io); }
491
+ catch (e) {
492
+ if (e.unconfirmed) throw scheduleError("E_SCHEDULE_INVALID", `agent: soul ${JSON.stringify(def.agent)} could not be confirmed: ${e.message}`, { field: "agent" });
493
+ if (e.refusal) throw scheduleError("E_SCHEDULE_INVALID", `agent: ${e.message}`, { field: "agent", details: { code: e.code } });
494
+ throw e;
495
+ }
481
496
  }
482
497
 
483
498
  // ----------------------------------------------------------------- time
@@ -556,6 +571,37 @@ export function workspaceSpawnContext(ws) {
556
571
  try { const found = loadLocal(ws); return { kind: "local", local: found.path, dir: dirname(found.path) }; }
557
572
  catch (e) { return { kind: "local", local: null, dir: ws, error: { code: e.code || "E_WORKSPACE_SCHEMA", message: e.message } }; }
558
573
  }
574
+ /** The `oats spawn` selectors a spawn job's run passes (beside its purpose, task and launch
575
+ * flags), so a preview checks what the run will: one builder for the run and its previews.
576
+ * Every value travels as ONE `--flag=value` token. */
577
+ function spawnSelectorArgs(opts) {
578
+ const argv = [];
579
+ if (opts.launchConfig) argv.push(`--launch-config=${opts.launchConfig}`);
580
+ if (opts.harness) argv.push(`--harness=${opts.harness}`);
581
+ if (opts.model) argv.push(`--model=${opts.model}`);
582
+ if (opts.backend) argv.push(`--backend=${opts.backend}`);
583
+ if (opts.repo) argv.push(`--repo=${opts.repo}`);
584
+ return argv;
585
+ }
586
+ /** The kernel's own `oats spawn <agent> --preview --json` in the deployment, with the job's
587
+ * selectors (spawnSelectorArgs): what the run's spawn would resolve and refuse, written nowhere.
588
+ * Answers the preview's result; throws spawn's refusal (its code and message, `refusal: true`),
589
+ * an unconfirmed answer (`unconfirmed: true`: interrupted, timed out, no envelope), or the
590
+ * deployment's own error. */
591
+ function spawnPreview(ws, def, { root, discover }, io) {
592
+ const context = workspaceSpawnContext(ws);
593
+ if (context.error) throw scheduleError(context.error.code, context.error.message);
594
+ if (String(def.agent).startsWith("-")) throw scheduleError("E_SCHEDULE_INVALID", `agent: ${JSON.stringify(def.agent)} is not a soul name`, { field: "agent" });
595
+ const argv = ["spawn", def.agent, `--dir=${context.dir}`, ...(discover ? [] : [`--agents-root=${root}`]), "--preview", "--json", ...spawnSelectorArgs(def)];
596
+ const r = runScheduleCommand(process.execPath, [io?.oatsBin || OATS_BIN, ...argv], { cwd: context.dir, timeout: io?.commandTimeoutMs || COMMAND_TIMEOUT_MS, graceMs: io?.commandGraceMs, maxBuffer: 16 * 1024 * 1024, env: childEnv() });
597
+ const unconfirmed = (message) => scheduleError("E_SPAWN_FAILED", message, { unconfirmed: true });
598
+ if (r.interrupted === true) throw unconfirmed("the spawn preview was interrupted; its result is unconfirmed");
599
+ if (r.error?.code === "ETIMEDOUT" || (r.status === null && ["SIGTERM", "SIGKILL"].includes(r.signal))) throw unconfirmed("the spawn preview timed out; its result is unconfirmed");
600
+ const envelope = parseEnvelopeText(r.stdout);
601
+ if (!envelope || typeof envelope.ok !== "boolean") throw unconfirmed(`the spawn preview answered no valid envelope (exit ${r.status ?? r.signal})`);
602
+ if (!envelope.ok) throw scheduleError(envelope.error?.code || "E_SPAWN_FAILED", String(envelope.error?.message || "spawn preview failed"), { refusal: true });
603
+ return envelope.result;
604
+ }
559
605
  /** A workspace spawn materializes EXACTLY like `oats spawn` — prepareInstance →
560
606
  * ensureWorkspaceSoul → spawnInstanceAsync (resolve over the remotes, copy every
561
607
  * module whole into the home, compose AGENTS.md from the modules' injects).
@@ -572,12 +618,7 @@ function spawnViaCli(ws, root, agent, opts, context, io) {
572
618
  // Every value travels as ONE `--flag=value` token, so no value can be read as a flag of its own;
573
619
  // the soul is the one positional, and an option-shaped one is refused.
574
620
  if (String(agent.name).startsWith("-")) throw scheduleError("E_SCHEDULE_INVALID", `agent: ${JSON.stringify(agent.name)} is not a soul name`, { field: "agent" });
575
- const argv = ["spawn", agent.name, `--dir=${context.dir}`, ...(opts.discover ? [] : [`--agents-root=${root}`]), `--purpose=${opts.purpose}`, "--json"];
576
- if (opts.launchConfig) argv.push(`--launch-config=${opts.launchConfig}`);
577
- if (opts.harness) argv.push(`--harness=${opts.harness}`);
578
- if (opts.model) argv.push(`--model=${opts.model}`);
579
- if (opts.backend) argv.push(`--backend=${opts.backend}`);
580
- if (opts.repo) argv.push(`--repo=${opts.repo}`);
621
+ const argv = ["spawn", agent.name, `--dir=${context.dir}`, ...(opts.discover ? [] : [`--agents-root=${root}`]), `--purpose=${opts.purpose}`, "--json", ...spawnSelectorArgs(opts)];
581
622
  if (opts.yolo === true) argv.push("--yolo"); else if (opts.yolo === false) argv.push("--no-yolo");
582
623
  if (opts.launch === false) argv.push("--no-launch");
583
624
  // The task is multi-line text of arbitrary size: it travels as a private file, never in argv.
@@ -1089,6 +1130,7 @@ export function reconcile(ws, qid, { io, now = new Date(), clear = false, ctx =
1089
1130
  });
1090
1131
  if (homes.length === 1) adopted = { instance: `${def.agent}-${purpose}`, home: homes[0] };
1091
1132
  else if (homes.length > 1) ambiguous = `${homes.length} homes named ${def.agent}-${purpose}: ${homes.join(", ")}`;
1133
+ else if (!clear && !runNameProven(ws, def)) return { schedule: describeHere(), reconciled: "unknown", remedy: `spawn names the runs of soul ${def.agent} after its own stem, not ${def.agent}-${purpose}, so the spawn's effects cannot be proven from its name; check the roster and the host by hand, then run oats schedule reconcile ${id} --clear to record launch-failed and free the slot, or oats schedule remove --force ${id}` };
1092
1134
  } else if (attemptKind === "command" || attemptKind === "operation") {
1093
1135
  const named = namedHomes(ws, js);
1094
1136
  if (named.length === 1) adopted = named[0];
@@ -1111,6 +1153,16 @@ export function reconcile(ws, qid, { io, now = new Date(), clear = false, ctx =
1111
1153
  });
1112
1154
  }
1113
1155
 
1156
+ /** Whether a spawn job's runs are named `<agent>-<purpose>`, so a home's absence proves a lost
1157
+ * receipt launched nothing: only for a bare name of a member soul under the agents root, whose
1158
+ * agent name is that name. Spawn names a run after the soul's stem (core.mjs
1159
+ * deriveInstanceName): a qualified name is resolved by spawn, and a package soul homes at
1160
+ * <package>--<soul>, its runs named <package>-<soul>-<purpose>. */
1161
+ function runNameProven(ws, def) {
1162
+ if (typeof def.agent !== "string" || def.agent.includes("/") || def.agent.includes("--")) return false;
1163
+ const [root] = scopeRoots(ws);
1164
+ return findAgent(root, def.agent)?.name === def.agent;
1165
+ }
1114
1166
  /** The homes in the scope of the instance a command attempt's answer named: its only adoptable
1115
1167
  * receipt. Exactly one is adoptable; none or several leave its effects unproven. */
1116
1168
  function namedHomes(ws, js) {
@@ -1235,18 +1287,7 @@ export function testSchedule(ws, qid, io, { now = new Date(), ctx = null } = {})
1235
1287
  soul = { name: def.agent, origin: row.soul?.origin ?? null, resolves: false, error: null };
1236
1288
  try {
1237
1289
  const { root, discover } = resolveScheduledAgent(ws, def);
1238
- const context = workspaceSpawnContext(ws);
1239
- if (context.error) throw scheduleError(context.error.code, context.error.message);
1240
- if (String(def.agent).startsWith("-")) throw scheduleError("E_SCHEDULE_INVALID", `agent: ${JSON.stringify(def.agent)} is not a soul name`, { field: "agent" });
1241
- const argv = ["spawn", def.agent, `--dir=${context.dir}`, ...(discover ? [] : [`--agents-root=${root}`]), "--preview", "--json"];
1242
- if (def.launchConfig) argv.push(`--launch-config=${def.launchConfig}`);
1243
- if (def.harness) argv.push(`--harness=${def.harness}`);
1244
- if (def.model) argv.push(`--model=${def.model}`);
1245
- const r = runScheduleCommand(process.execPath, [io?.oatsBin || OATS_BIN, ...argv], { cwd: context.dir, timeout: io?.commandTimeoutMs || COMMAND_TIMEOUT_MS, graceMs: io?.commandGraceMs, maxBuffer: 16 * 1024 * 1024, env: childEnv() });
1246
- if (r.interrupted === true) throw scheduleError("E_SPAWN_FAILED", "the spawn preview was interrupted; its result is unconfirmed");
1247
- const envelope = parseEnvelopeText(r.stdout);
1248
- if (!envelope || typeof envelope.ok !== "boolean") throw scheduleError("E_SPAWN_FAILED", `the spawn preview answered no valid envelope (exit ${r.status ?? r.signal})`);
1249
- if (!envelope.ok) throw scheduleError(envelope.error?.code || "E_SPAWN_FAILED", String(envelope.error?.message || "spawn preview failed"));
1290
+ spawnPreview(ws, def, { root, discover }, io);
1250
1291
  soul.resolves = true;
1251
1292
  } catch (e) {
1252
1293
  soul.error = { code: e.code || "E_SPAWN_FAILED", message: e.message };
@@ -1352,7 +1393,7 @@ export function listSchedules(ws, io, { now = new Date(), ctx = null } = {}) {
1352
1393
  return { scope: ws, scheduleApi: 2, scheduleHistoryApi: SCHEDULE_HISTORY_API, integrity: scheduleIntegrity(ws), host: { name: ctx?.host?.name ?? null, ghUser: ctx?.ghUsers ? ctx.ghUsers() : {} }, schedules: [...local, ...workspace], triggers: { count: triggers, command: "oats trigger list" }, snapshot: ctx?.snapshot ? { takenAt: ctx.snapshot.takenAt, problems: (ctx.snapshot.problems || []).length } : null, scheduler: schedulerStatus(ws, io) };
1353
1394
  }
1354
1395
  export function addSchedule(ws, spec, io) {
1355
- const def = validateDefinition(ws, spec);
1396
+ const def = validateDefinition(ws, spec, { io });
1356
1397
  return withScopeLock(ws, () => {
1357
1398
  const defs = readDefinitions(ws);
1358
1399
  if (defs.jobs[def.id]) throw scheduleError("E_SCHEDULE_EXISTS", `schedule ${def.id} already exists in ${ws}`);
@@ -1368,7 +1409,7 @@ export function addSchedule(ws, spec, io) {
1368
1409
  * while the job holds a slot or has an unresolved attempt; timing and text can. */
1369
1410
  export function updateSchedule(ws, qid, spec, io) {
1370
1411
  const id = localScheduleId(qid, "update");
1371
- const def = validateDefinition(ws, { ...spec, id });
1412
+ const def = validateDefinition(ws, { ...spec, id }, { io });
1372
1413
  return withHostLock(() => withScopeLock(ws, () => {
1373
1414
  const defs = readDefinitions(ws);
1374
1415
  if (!defs.jobs[id] || defs.jobs[id].kind === "trigger") throw scheduleError("E_SCHEDULE_UNKNOWN", `no schedule ${JSON.stringify(id)} in ${ws}${defs.jobs[id] ? " (it is a trigger: use oats trigger)" : ""}`);
@@ -8,7 +8,7 @@
8
8
  },
9
9
  "oats.aweb": {
10
10
  "url": "https://github.com/awebai/oats-aweb.git",
11
- "ref": "v1.33.1",
11
+ "ref": "v1.34.0",
12
12
  "path": "oats-package"
13
13
  },
14
14
  "oats.jira": {
@@ -48,7 +48,7 @@
48
48
  },
49
49
  "oats.framework": {
50
50
  "url": "https://github.com/awebai/oats.git",
51
- "ref": "oats-framework/v1.19.0",
51
+ "ref": "oats-framework/v1.20.0",
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.9",
3
+ "version": "0.69.10",
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",