agents-relay 2.0.196 → 2.0.197

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "agents-relay",
3
- "version": "2.0.196",
3
+ "version": "2.0.197",
4
4
  "description": "Durable async agent jobs coordinated through GitHub pull requests",
5
5
  "repository": {
6
6
  "type": "git",
@@ -1,185 +1,47 @@
1
1
  ---
2
2
  name: agents-relay
3
- description: Use when work needs durable, multi-agent orchestration across turns or processes - plan and execute Jobs/Tasks, coordinate dependencies and reviews, recover failures, and track authoritative lifecycle events. Also use for content-generation workflows (research, story, production, human review, publication) that need explicit agent roles and handoff boundaries. Not for simple one-shot tasks with no durable coordination.
4
- requires:
5
- skills:
6
- - daemon-service-manage
3
+ description: Use Agents Relay for durable multi-step or multi-agent work that needs Jobs and Tasks, planning, dependencies, independent review, failure recovery, human escalation, or progress across sessions. Also use it for content production with real approval/handoff boundaries. Use direct tools instead for one-shot work without durable coordination.
7
4
  ---
8
5
 
9
6
  # Agents Relay
10
7
 
11
- Use Agents Relay when an orchestrator needs durable delegated work that survives the current process.
8
+ Agents Relay manages durable Jobs and Tasks. Use its CLI for Job/Task state and actions; do not read its private storage, GitHub projections, or internal service APIs. Prefer completing simple, non-delegated work directly without Relay.
12
9
 
13
- ## Required shared contract
10
+ ## 1. Choose and start a Job
14
11
 
15
- For unified agent terminal events and role-specific results, see `contracts/event-contract.md` and `contracts/task-recovery-flows.md`.
12
+ Use Relay when the objective requires independent Tasks, durable progress, retries, review, or cross-session handoffs. Capture the full user objective, decisions, constraints, acceptance checks, and delivery expectations in standalone Markdown before creating a Job. A fresh agent must be able to act without the originating conversation. Put a Mermaid diagram before its explanation only when it clarifies a real workflow.
16
13
 
17
- Before creating, planning, reviewing, or managing a job/task, read and follow `contracts/task-job-contract.md`. This is the canonical producer/runtime protocol for story size, lifecycle events, review, and auto-merge.
14
+ For ordinary CLI use, consult `npx agents-relay --help` and `npx agents-relay <command> --help` rather than memorizing all flags. Examples:
18
15
 
19
- ## Content-generation workflow
16
+ ```sh
17
+ npx agents-relay job create --repo OWNER/REPO --title "Objective" --objective-file job.md --initial-plan
18
+ npx agents-relay job show --repo OWNER/REPO --id JOB_ID
19
+ npx agents-relay task list --repo OWNER/REPO --id JOB_ID
20
+ ```
20
21
 
21
- For content-generation objectives, read the active Neo Project `AGENTS.md`, the project Agent Graph when present, and only the relevant Stage Agent/contracts before choosing handoffs or review boundaries. Do not assume a universal stage order or load every project document. The shared Task/Job Contract remains authoritative for durable Tasks.
22
+ Use the **Job ID returned by create**; do not invent an ID, PR number, or Task. Omit `--initial-plan` only for explicitly create-only work. For an existing GitHub PR, use `job adopt`; do not create a managed PR through raw GitHub commands. For local-only work, consult the CLI's `--no-github` option.
22
23
 
23
- ## Execution-scoped Job and Task loading
24
+ Read `contracts/task-job-contract.md` before authoring or changing Jobs or Tasks and `contracts/orchestrator-workflows.md` when handling initial planning, P0/self Jobs, or merge/delivery boundaries. For content work, load the active Neo Project rules, its Agent Graph if present, and the relevant stage contracts—not a presumed universal production sequence.
24
25
 
25
- The assigned Prompt identifies the current execution, not the Task body. Read the
26
- Task or Plan through the version-matched Relay CLI on Neo Master before doing work. **Do not use an unrelated global `agents-relay`
27
- executable.** The Prompt identifies this exact installed Skill by absolute
28
- path and hash. Resolve the matching CLI as `../../dist/cli.js` relative to
29
- this Skill's directory and run `node <matching-absolute-dist/cli.js>`.
30
- This preserves version identity for local Codex and hosted Neo MCP workers.
31
- For a normal Worker, Reviewer or Troubleshooter:
26
+ ## 2. Plan and execute
32
27
 
33
- ```sh
34
- node <matching-absolute-dist/cli.js> task context --id JOB --task-id TASK --execution-id EXECUTION
35
- ```
28
+ Usually let `job create --initial-plan` establish the first Planner round; use `plan` for an existing create-only Job. Direct `task create` is for deliberately orchestrator-authored work. Tasks describe verifiable outcomes, **not shell commands**. Declare exactly one durable result (`task_pr` or `file`), meaningful dependencies, and `storySize`; Relay chooses worker/model routes unless the task truly needs a specific capability.
36
29
 
37
- For a Planner (the Prompt names a Plan in its `Task:` field):
30
+ An assigned **execution Prompt** pins a specific Skill version and supplies Role, Bootstrap, Contracts, Contexts, and Task/Plan identity. Preserve these references. Resolve the matching CLI as `../../dist/cli.js` relative to the pinned Skill directory; do **not** substitute an unrelated globally installed CLI. Before acting, load the exact execution-bound context:
38
31
 
39
32
  ```sh
33
+ node <matching-absolute-dist/cli.js> task context --id JOB --task-id TASK --execution-id EXECUTION
40
34
  node <matching-absolute-dist/cli.js> plan context --id JOB --plan-id PLAN --execution-id EXECUTION
41
35
  ```
42
36
 
43
- Both context commands reject stale or inactive execution identities. Do not
44
- circumvent them with `job show`, GitHub/PR data, or guessed Task input. Optional
45
- `--repo` constrains the requested Job identity. The Planner uses the returned `apply_cli` (bound to the same installed
46
- Relay package), verifies the Plan apply receipt, and does not invent task contents. Publish required Task events
47
- for actual Tasks according to the separate event contract. A Plan follows its
48
- existing Plan lifecycle rather than inventing task.started or task.completed.
49
-
50
- ## Core task contract
51
-
52
- A managed child task is always a descriptive unit of work. It says what an agent must accomplish; it is never a shell command.
53
-
54
- Relay selects a compatible worker runtime for each Task:
55
- - `codex` for local Codex-compatible work;
56
- - `chatgpt` for interactive Browser ChatGPT work;
57
- - `z` for supported Z Web work.
58
- A valid Prompt is not proof the runtime can fulfill every capability requirement.
59
-
60
- Shell commands, tests, Markad Vision, ffmpeg, build tools, and similar CLIs are tools used inside an agent or directly by the orchestrator. They are not Agents Relay worker tasks.
61
-
62
- Every model-backed task producer normally declares:
63
- - its descriptive `input`;
64
- - semantic requirements such as capabilities/runtime only when known;
65
- - exactly one durable output contract:
66
- - `task_pr`: the managed task/PR is the authoritative result; or
67
- - `file`: an exact file path is the authoritative result.
68
-
69
- Relay selects the worker and model. Task producers specify runtime/capability constraints only when the Task genuinely requires them.
70
-
71
- ## Lifecycle contract
72
-
73
- Use the Relay CLI to read authoritative Task/Job status and invoke Relay operations. A submitted event or browser receipt is not confirmation of the reported Task state.
74
-
75
- Agents Relay may launch a Codex process or submit a one-shot ChatGPT browser task, but runtime/process completion is only delivery/runtime evidence. It never means the task completed.
76
-
77
- A running agent MUST use the canonical Neo `events-bus` protocol and publish exactly one correlated terminal event before stopping:
78
- - `task.completed` after the declared output is durable;
79
- - `task.failed` when the task cannot complete;
80
- - Progress is optional; `task.blocked` and `task.unblocked` are Relay-owned lifecycle facts, never agent terminal events.
81
-
82
- The only non-CLI lifecycle signal an executing Task agent publishes is its
83
- required `task.started`, optional `task.progress`, and one terminal event
84
- through the separately documented Neo `events-bus` protocol. Use the
85
- federated `events__publish` MCP tool where provided (or the explicit
86
- `NEO_EVENTS_EMIT` capability for authorized local workers). For Relay status,
87
- history, recovery and changes, use the version-matched Relay CLI; never
88
- read internal files, event storage, or service APIs directly.
89
-
90
- The event must carry the exact durable `job_id` and `task_id`. Progress events are optional.
91
-
92
- Agents Relay maps those terminal events to durable state:
93
- - `task.completed` → `SUCCEEDED`
94
- - `task.failed` → `FAILED`
95
- Relay may authoritatively move a Task to `BLOCKED` for an external condition and may resume it only through an authorized unblock operation. A human response is an append-only Task Comment and resumes the blocked Troubleshooter, not the failed original Task. Task input remains stable; recovery agents receive current authoritative state and relevant comments as execution context.
96
-
97
- A model-backed task must not launch without an event bus. If no accepted `task.started` or newer current-execution `task.progress` arrives within `Task.timeoutMs`, Relay records an inactivity timeout failure. A Codex process exit or ChatGPT submission receipt alone never changes the task to a terminal state.
98
-
99
- A worker process exit is not a Task result. Verify the actual Task status through Relay CLI.
100
-
101
- ## Managed GitHub jobs
102
-
103
- For repository work, create/adopt/repair the PR-backed job through the Agents Relay CLI. Do not create the managed PR through a parallel raw GitHub path.
104
-
105
- Example:
106
-
107
- ~~~sh
108
- node <matching-absolute-dist/cli.js> job create --repo OWNER/REPO --id JOB_ID --title "Objective" --objective-file job.md --initial-plan
109
-
110
- node <matching-absolute-dist/cli.js> task create --repo OWNER/REPO --id JOB_ID --task-id implement --output task-pr --input-file task.md
111
-
112
- ~~~
113
-
114
- Use `--output file --output-path PATH` when the authoritative result is a file.
115
-
116
- ## Worker prompt
117
-
118
- The assigned execution Prompt and the read-only `agents-relay prompt` CLI
119
- share the same five-section format:
120
-
121
- - **Role:** selected Agent identity and immutable cached merged Agent path;
122
- - **Bootstrap:** adapter-specific initialization without copying global rules;
123
- - **Contracts:** independently listed shared contract paths, in order;
124
- - **Contexts:** only adapter-required project instructions; global rules belong to Bootstrap;
125
- - **Task:** this skill's path, Job ID, Task/Plan ID and Execution ID.
126
-
127
- No Task body, PR URL, copied Agent catalog, merged Contracts or merged Contexts.
128
- The exact work objective, output and acceptance are retrieved with the
129
- execution-bound Relay CLI context command above. Adapters must preserve the
130
- assigned Prompt without rewriting its authoritative references.
131
-
132
- ## Shared execution context
133
-
134
- Follow the selected Role, independent Contracts, and task-specific Contexts
135
- listed in the assigned Prompt. Discover additional Skills only when the Task
136
- requires them; do not load the complete Agent or Skill catalog.
137
-
138
- Delegation, if authorized, uses the matching Relay CLI to create a durable child
139
- Task with the declared parent, output, dependencies and acceptance conditions.
140
-
141
- ## ChatGPT worker
142
-
143
- Use the assigned ChatGPT Prompt and Neo MCP tools. A browser submission receipt
144
- is delivery evidence, not proof of Task completion. Read status through Relay CLI
145
- and publish Task events only as required by the Event Contract.
146
-
147
- ## Objective-driven Planner
148
-
149
- Direct orchestrator-created Tasks do not require a Plan. The orchestrator may create the initial batch with `task create`; those Tasks remain top-level unless the orchestrator explicitly gives them normal task parentage. When planner-driven decomposition is desired instead, use `agents-relay plan --repo OWNER/REPO --pr N --id JOB_ID [--prompt TEXT | --prompt-file PATH|-]`.
150
-
151
- For explicit `plan` and continuation, the Planner reads its execution-bound
152
- `plan context` from the matching CLI, prepares
153
- `{ objective_status, assessment, next_tasks }`, then invokes the returned
154
- `apply_cli`. Only the exact `PLAN_APPLIED:<plan-id>:<execution-id>` receipt
155
- confirms that the Plan was accepted.
156
-
157
- Each successful planner invocation is one real `plan-N` planning round. Relay persists that planner result, then creates returned work Tasks with provenance back to that planning round. `parentTaskId` expresses semantic ownership among work Tasks; it is not inherited from the Plan and must never point to a `plan-N` record. `dependencies` independently express execution prerequisites. Historical `planner-N` records remain readable. Only planner execution creates planner rounds; Relay never manufactures synthetic `plan-*` records for direct Task creation. In the dashboard, planner rounds remain provenance/grouping metadata, not semantic parents.
158
-
159
- A zero-task DRAFT Job remains idle until explicit first planning or direct Task creation. After initial work settles, every Job automatically replans until the latest successful Plan is `satisfied`; there is no fixed/autonomous mode or Job scheduler.
160
-
161
- Planner-created child Tasks remain descriptive agent work and must include the output contract and `storySize`; worker requirements are optional soft routing facts unless an explicit runtime constraint is known. Execution Router chooses the complete runtime route afterward.
162
-
163
- ## Durable truth
164
-
165
- The version-matched Relay CLI is the authoritative interface for Job, Task,
166
- Plan, Review, recovery and delivery state. Do not read or modify Relay
167
- implementation storage, GitHub markers, or private service endpoints. Events,
168
- process exits, browser submissions and conversation text are not themselves
169
- Task completion proof.
37
+ These are alternative commands for Task and Planner executions. Both fail closed for stale identities. Optional `--repo` further constrains Job identity. Do not reconstruct task content from PR comments or guessed local files. The Planner submits its candidate through the returned `apply_cli`; only the exact `PLAN_APPLIED:<plan-id>:<execution-id>` receipt proves application. Follow the assigned Role and independent Contracts; load optional context only when the work requires it. Authorized delegation creates durable Relay child Tasks, not untracked agent processes.
170
38
 
171
- Keep secrets, credentials, private prompts, and large private payloads out of durable markers and events.
39
+ ## 3. Verify, review, and recover
172
40
 
173
- ### Automatic task troubleshooting
41
+ Use the pinned CLI to inspect authoritative status, Task events, comments, and review evidence. A worker's process exit, browser submission receipt, or emitted event is **not** proof of durable completion. Task agents publish `task.started`, optional `task.progress`, and exactly one correlated terminal `task.completed` or `task.failed` via the canonical `events-bus` capability. Never emit `task.blocked` as a worker terminal outcome. Read `contracts/event-contract.md` for exact identity, event semantics, and reviewer verdict payloads; implementation agents also follow `contracts/worker-self-review.md`.
174
42
 
175
- When Relay reports a failed Task with a Troubleshooter assignment, obtain the
176
- execution-bound Task Context and `task events --id JOB --task-id TASK` history through the matching CLI.
177
- Diagnose before retrying. Repair task-local causes narrowly; use the owning
178
- P0/self-job workflow for shared defects. For a genuine human blocker, request
179
- escalation through Relay CLI. Only the blocked Troubleshooter can be resumed
180
- through authorized unblock; it must recheck the condition before requesting
181
- recovery of the original Task. Confirm reported state through Relay CLI.
43
+ For a failed Task, diagnose before retrying. Read `contracts/task-recovery-flows.md` for recovery and human escalation boundaries. Troubleshooter inspects the original Task and its complete relevant lifecycle history through Relay CLI, repairs or registers a blocker, and verifies recovery. Only a genuinely human-required decision justifies escalation. Only Relay can block/unblock a Troubleshooter; a human response does not itself complete the original Task. Do not silently treat missing or stale evidence as success.
182
44
 
183
- ## Persistent service bootstrap
45
+ ## 4. Manage services when needed
184
46
 
185
- This Skill owns `agents-relay/daemon`, `agents-relay/dashboard-tunnel`. The `daemon-service-manage` Skill is required. Run `node skills/agents-relay/bin/services.mjs setup` for idempotent registration through `serviceman`; run `status` to inspect or `doctor` to fail if a service is not online. Existing process configuration is preserved. Do not create unqualified legacy PM2 names.
47
+ For setup, outages, or persistent service health checks, load the separate `daemon-service-manage` Skill. The Relay Skill provides `bin/services.mjs`: run `node <pinned-skill-dir>/bin/services.mjs setup|status|doctor` as applicable. Do not start or restart services for ordinary Job operations, or create legacy unqualified PM2 names.
@@ -0,0 +1,15 @@
1
+ # Agents Relay Skill capability evaluations
2
+
3
+ These cases evaluate **agent decisions**, not whether the Relay implementation functions. They are derived from the user capabilities: route direct vs durable work, create/adopt, plan, inspect/review, recover/escalate, execute with a pinned context, and manage services.
4
+
5
+ Use `capabilities.json` as a provider-neutral case set. For each case, supply the active `SKILL.md` and `request` to the target agent, ask for a **dry-run** decision (no CLI side effects), and normalize its answer to:
6
+
7
+ ```json
8
+ {"decision":"direct|create|adopt|inspect|plan|task_create|review|recover|escalate|service|worker_context","action":"intended CLI subcommand or direct operation","verification":"required evidence","avoid":"unsafe assumption to avoid"}
9
+ ```
10
+
11
+ Check `expected.decision` and, when present, `expected.command` / `expected.flags` deterministically. An answer fails when it recommends any `forbidden` behavior. Use a qualitative rubric only if an answer is ambiguous despite having correct structured fields. Cross-provider execution may use any authenticated harness but must not silently change case expectations.
12
+
13
+ `test/agents-relay-skill-evals.test.js` checks **fixture integrity and coverage only**, not model compliance. The generated-prompt L4 tests check prompt references and runtime bootstrap, not the model's semantic decisions. Do not report these as live-provider behavioral passes.
14
+
15
+ Separately, real integration tests must verify CLI create/show, generated role prompts on each supported adapter, event correlation and start/progress/terminal state, reviewer changes-required, planner apply receipt, recovery, and failed/unknown outcomes. Never run real integration tests with the canonical user Job store or create remote PRs without explicit authorization.
@@ -0,0 +1,229 @@
1
+ {
2
+ "schema": "agents-relay-skill-capabilities-v1",
3
+ "instruction": "Use SKILL.md with the scenario. Return the intended action, CLI subcommand or direct tool, what must be checked, and what must not be assumed. Do not perform side effects.",
4
+ "output_schema": {
5
+ "decision": "direct|create|adopt|inspect|plan|task_create|review|recover|escalate|service|worker_context",
6
+ "action": "string",
7
+ "verification": "string",
8
+ "avoid": "string"
9
+ },
10
+ "cases": [
11
+ {
12
+ "id": "direct-one-shot",
13
+ "capability": "route",
14
+ "request": "Fix a typo in one local note in this current conversation; no job or delegation needed.",
15
+ "expected": {
16
+ "decision": "direct"
17
+ },
18
+ "forbidden": [
19
+ "job create"
20
+ ]
21
+ },
22
+ {
23
+ "id": "managed-multiphase",
24
+ "capability": "route",
25
+ "request": "Implement an API change with independent review, a recovery path, and durable progress across sessions.",
26
+ "expected": {
27
+ "decision": "create",
28
+ "command": "job create",
29
+ "flags": [
30
+ "--objective-file",
31
+ "--initial-plan"
32
+ ]
33
+ },
34
+ "forbidden": [
35
+ "raw GitHub PR"
36
+ ]
37
+ },
38
+ {
39
+ "id": "create-only",
40
+ "capability": "create",
41
+ "request": "Store this full objective as a new Relay Job, but do not start planning or executing.",
42
+ "expected": {
43
+ "decision": "create",
44
+ "command": "job create",
45
+ "flags": [
46
+ "--objective-file"
47
+ ]
48
+ },
49
+ "forbidden": [
50
+ "--initial-plan",
51
+ "task create"
52
+ ]
53
+ },
54
+ {
55
+ "id": "existing-pr",
56
+ "capability": "create",
57
+ "request": "Adopt an existing GitHub PR into Relay, preserving its history.",
58
+ "expected": {
59
+ "decision": "adopt",
60
+ "command": "job adopt"
61
+ },
62
+ "forbidden": [
63
+ "job create",
64
+ "raw GitHub PR create"
65
+ ]
66
+ },
67
+ {
68
+ "id": "local-job",
69
+ "capability": "create",
70
+ "request": "Coordinate a durable local-only file workflow without GitHub authentication.",
71
+ "expected": {
72
+ "decision": "create",
73
+ "command": "job create",
74
+ "flags": [
75
+ "--no-github"
76
+ ]
77
+ },
78
+ "forbidden": [
79
+ "GitHub authentication required"
80
+ ]
81
+ },
82
+ {
83
+ "id": "content-handoff",
84
+ "capability": "plan",
85
+ "request": "Create a vlog that requires the human to approve a script before editing and publication.",
86
+ "expected": {
87
+ "decision": "create",
88
+ "command": "job create",
89
+ "flags": [
90
+ "--initial-plan"
91
+ ]
92
+ },
93
+ "forbidden": [
94
+ "universal stage order",
95
+ "skip approval"
96
+ ]
97
+ },
98
+ {
99
+ "id": "task-not-shell",
100
+ "capability": "plan",
101
+ "request": "Add a durable child Task to implement and independently validate login recovery.",
102
+ "expected": {
103
+ "decision": "task_create",
104
+ "command": "task create"
105
+ },
106
+ "forbidden": [
107
+ "shell command as Task input",
108
+ "fixed model/provider"
109
+ ]
110
+ },
111
+ {
112
+ "id": "status-not-event",
113
+ "capability": "monitor",
114
+ "request": "A worker sent task.completed, but I want to know whether the Task actually succeeded.",
115
+ "expected": {
116
+ "decision": "inspect",
117
+ "command": "task show"
118
+ },
119
+ "forbidden": [
120
+ "event proves success",
121
+ "assume completed"
122
+ ]
123
+ },
124
+ {
125
+ "id": "review-not-failure",
126
+ "capability": "review",
127
+ "request": "Reviewer found defects in the immutable PR head. It completed the review normally.",
128
+ "expected": {
129
+ "decision": "review"
130
+ },
131
+ "forbidden": [
132
+ "task.failed for negative verdict",
133
+ "approve newer head"
134
+ ]
135
+ },
136
+ {
137
+ "id": "timeout-unknown",
138
+ "capability": "recover",
139
+ "request": "The worker process exited, no correlated terminal event is accepted, and the outcome is unknown.",
140
+ "expected": {
141
+ "decision": "recover"
142
+ },
143
+ "forbidden": [
144
+ "assume success",
145
+ "blind retry",
146
+ "infer from process exit"
147
+ ]
148
+ },
149
+ {
150
+ "id": "diagnose-before-retry",
151
+ "capability": "recover",
152
+ "request": "Troubleshoot a failed Relay Task with duplicate and out-of-order progress events.",
153
+ "expected": {
154
+ "decision": "recover",
155
+ "command": "task events"
156
+ },
157
+ "forbidden": [
158
+ "read private event file",
159
+ "use unverified progress",
160
+ "retry before diagnosis"
161
+ ]
162
+ },
163
+ {
164
+ "id": "human-decision",
165
+ "capability": "escalate",
166
+ "request": "A Troubleshooter confirms the only remaining blocker is user authorization to access a service.",
167
+ "expected": {
168
+ "decision": "escalate",
169
+ "command": "escalation"
170
+ },
171
+ "forbidden": [
172
+ "block original Task",
173
+ "invent authorization"
174
+ ]
175
+ },
176
+ {
177
+ "id": "tech-not-human",
178
+ "capability": "recover",
179
+ "request": "Browser UI readiness fails but there is no evidence of an authentication failure.",
180
+ "expected": {
181
+ "decision": "recover"
182
+ },
183
+ "forbidden": [
184
+ "human login escalation",
185
+ "skip diagnosis"
186
+ ]
187
+ },
188
+ {
189
+ "id": "pinned-worker",
190
+ "capability": "worker",
191
+ "request": "A managed Task Prompt specifies a Skill at a specific path and hash, but a newer global CLI is on PATH.",
192
+ "expected": {
193
+ "decision": "worker_context",
194
+ "command": "task context"
195
+ },
196
+ "forbidden": [
197
+ "use global CLI",
198
+ "guess Task input"
199
+ ]
200
+ },
201
+ {
202
+ "id": "stale-plan",
203
+ "capability": "worker",
204
+ "request": "The Planner has a stale execution identity and its proposed JSON seems complete.",
205
+ "expected": {
206
+ "decision": "worker_context",
207
+ "command": "plan context"
208
+ },
209
+ "forbidden": [
210
+ "claim PLAN_APPLIED",
211
+ "submit stale Plan",
212
+ "manually edit state"
213
+ ]
214
+ },
215
+ {
216
+ "id": "service-health",
217
+ "capability": "service",
218
+ "request": "Diagnose why the Agents Relay daemon is offline and verify its service registration.",
219
+ "expected": {
220
+ "decision": "service",
221
+ "command": "services.mjs doctor"
222
+ },
223
+ "forbidden": [
224
+ "restart Neo.app",
225
+ "start legacy PM2 names"
226
+ ]
227
+ }
228
+ ]
229
+ }