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,185 +1,47 @@
|
|
|
1
1
|
---
|
|
2
2
|
name: agents-relay
|
|
3
|
-
description: Use
|
|
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
|
-
|
|
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
|
-
##
|
|
10
|
+
## 1. Choose and start a Job
|
|
14
11
|
|
|
15
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
39
|
+
## 3. Verify, review, and recover
|
|
172
40
|
|
|
173
|
-
|
|
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
|
-
|
|
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
|
-
##
|
|
45
|
+
## 4. Manage services when needed
|
|
184
46
|
|
|
185
|
-
|
|
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
|
+
}
|