owenloop 0.5.14 → 0.5.16
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/CHANGELOG.md +21 -0
- package/README.md +7 -3
- package/dist/packages/work/src/agent/loop.js +71 -2
- package/dist/packages/work/src/credentials/reader.d.ts +10 -8
- package/dist/packages/work/src/credentials/reader.js +10 -8
- package/dist/packages/work/src/credentials/resolve.d.ts +14 -5
- package/dist/packages/work/src/credentials/resolve.js +51 -5
- package/dist/packages/work/src/harness/claude.d.ts +1 -1
- package/dist/packages/work/src/harness/claude.js +12 -9
- package/dist/packages/work/src/harness/codex.js +4 -1
- package/dist/packages/work/src/harness/contract.d.ts +9 -1
- package/dist/packages/work/src/harness/gatekeeper.d.ts +22 -6
- package/dist/packages/work/src/harness/gatekeeper.js +35 -27
- package/dist/packages/work/src/roles/approvals.d.ts +10 -7
- package/dist/packages/work/src/roles/approvals.js +15 -12
- package/dist/packages/work/src/shift/loop.js +12 -4
- package/dist/packages/work/src/usage.d.ts +1 -1
- package/dist/packages/work/src/usage.js +37 -14
- package/dist/src/cli.d.ts +6 -0
- package/dist/src/cli.js +135 -20
- package/docs/agent-runner.md +16 -2
- package/docs/cli.md +77 -14
- package/docs/shift-logs.md +13 -0
- package/package.json +1 -1
- package/plugins/claude-code/plugin/.claude-plugin/plugin.json +1 -1
- package/plugins/claude-code/plugin/.mcp.json +1 -1
- package/plugins/codex/plugins/owenloop/.codex-plugin/plugin.json +1 -1
- package/plugins/codex/plugins/owenloop/.mcp.json +1 -1
|
@@ -31,23 +31,25 @@
|
|
|
31
31
|
* whole point of the list.
|
|
32
32
|
*
|
|
33
33
|
* COMMANDS
|
|
34
|
-
* owenloop work approvals [--json] every approval a worker is blocked on
|
|
35
|
-
* owenloop work approvals approve <wf>/<run> <tool-use-id> [--note <text>]
|
|
36
|
-
* owenloop work approvals deny <wf>/<run> <tool-use-id> [--note <text>]
|
|
34
|
+
* owenloop work approvals [--origin <url>] [--json] every approval a worker is blocked on
|
|
35
|
+
* owenloop work approvals approve <wf>/<run> <tool-use-id> [--origin <url>] [--note <text>]
|
|
36
|
+
* owenloop work approvals deny <wf>/<run> <tool-use-id> [--origin <url>] [--note <text>]
|
|
37
37
|
*
|
|
38
38
|
* The decision is a positional VERB rather than an `--approve` flag, because a
|
|
39
39
|
* flag that grants a dangerous command is one typo away from being omitted, and
|
|
40
40
|
* an omitted flag has to mean something. A verb cannot be omitted.
|
|
41
41
|
*
|
|
42
|
-
* Origin
|
|
43
|
-
*
|
|
44
|
-
* (default `default`).
|
|
45
|
-
*
|
|
42
|
+
* Origin resolves as in `release`: `--origin` → settings `hubOrigin`.
|
|
43
|
+
* Listing reads the `agent:<account>` credential slot selected by
|
|
44
|
+
* `OWENLOOP_ACCOUNT` (default `default`). Approve and deny always read the
|
|
45
|
+
* stored `human` slot because the hub correctly reserves `answer_approval`
|
|
46
|
+
* for a person's key.
|
|
46
47
|
*
|
|
47
48
|
* Exit codes: 0 on success (including an empty list) · 1 on a hub/network error
|
|
48
49
|
* · 2 on a usage error.
|
|
49
50
|
*/
|
|
50
51
|
import { type HubClient } from '../hub/client.ts';
|
|
52
|
+
import { type BearerResult, type ResolveBearerArgs } from '../credentials/resolve.ts';
|
|
51
53
|
type Action = 'list' | 'approve' | 'deny';
|
|
52
54
|
interface ParsedArgs {
|
|
53
55
|
action: Action;
|
|
@@ -71,6 +73,7 @@ export interface RunDeps {
|
|
|
71
73
|
err?: (line: string) => void;
|
|
72
74
|
env?: Record<string, string | undefined>;
|
|
73
75
|
now?: () => number;
|
|
76
|
+
resolveBearer?: (args: ResolveBearerArgs) => Promise<BearerResult>;
|
|
74
77
|
}
|
|
75
78
|
export declare function run(args: string[], deps?: RunDeps): Promise<number>;
|
|
76
79
|
export {};
|
|
@@ -31,18 +31,19 @@
|
|
|
31
31
|
* whole point of the list.
|
|
32
32
|
*
|
|
33
33
|
* COMMANDS
|
|
34
|
-
* owenloop work approvals [--json] every approval a worker is blocked on
|
|
35
|
-
* owenloop work approvals approve <wf>/<run> <tool-use-id> [--note <text>]
|
|
36
|
-
* owenloop work approvals deny <wf>/<run> <tool-use-id> [--note <text>]
|
|
34
|
+
* owenloop work approvals [--origin <url>] [--json] every approval a worker is blocked on
|
|
35
|
+
* owenloop work approvals approve <wf>/<run> <tool-use-id> [--origin <url>] [--note <text>]
|
|
36
|
+
* owenloop work approvals deny <wf>/<run> <tool-use-id> [--origin <url>] [--note <text>]
|
|
37
37
|
*
|
|
38
38
|
* The decision is a positional VERB rather than an `--approve` flag, because a
|
|
39
39
|
* flag that grants a dangerous command is one typo away from being omitted, and
|
|
40
40
|
* an omitted flag has to mean something. A verb cannot be omitted.
|
|
41
41
|
*
|
|
42
|
-
* Origin
|
|
43
|
-
*
|
|
44
|
-
* (default `default`).
|
|
45
|
-
*
|
|
42
|
+
* Origin resolves as in `release`: `--origin` → settings `hubOrigin`.
|
|
43
|
+
* Listing reads the `agent:<account>` credential slot selected by
|
|
44
|
+
* `OWENLOOP_ACCOUNT` (default `default`). Approve and deny always read the
|
|
45
|
+
* stored `human` slot because the hub correctly reserves `answer_approval`
|
|
46
|
+
* for a person's key.
|
|
46
47
|
*
|
|
47
48
|
* Exit codes: 0 on success (including an empty list) · 1 on a hub/network error
|
|
48
49
|
* · 2 on a usage error.
|
|
@@ -112,9 +113,9 @@ export function splitOrder(order) {
|
|
|
112
113
|
return { workflow: order.slice(0, slash), run: order.slice(slash + 1) };
|
|
113
114
|
}
|
|
114
115
|
function usage(err) {
|
|
115
|
-
err('usage: owenloop work approvals [--json]');
|
|
116
|
-
err(' owenloop work approvals approve <workflow>/<run> <tool-use-id> [--note <text>]');
|
|
117
|
-
err(' owenloop work approvals deny <workflow>/<run> <tool-use-id> [--note <text>]');
|
|
116
|
+
err('usage: owenloop work approvals [--origin <url>] [--json]');
|
|
117
|
+
err(' owenloop work approvals approve <workflow>/<run> <tool-use-id> [--origin <url>] [--note <text>]');
|
|
118
|
+
err(' owenloop work approvals deny <workflow>/<run> <tool-use-id> [--origin <url>] [--note <text>]');
|
|
118
119
|
}
|
|
119
120
|
function errMsg(err) {
|
|
120
121
|
return err instanceof Error ? err.message : String(err);
|
|
@@ -172,8 +173,10 @@ export async function run(args, deps = {}) {
|
|
|
172
173
|
err('owenloop work approvals: no hub origin — pass --origin <url> or set hubOrigin in settings');
|
|
173
174
|
return 2;
|
|
174
175
|
}
|
|
175
|
-
const
|
|
176
|
-
|
|
176
|
+
const bearerArgs = parsed.action === 'list'
|
|
177
|
+
? { principal: 'agent', origin, account: env['OWENLOOP_ACCOUNT'] ?? 'default', env }
|
|
178
|
+
: { principal: 'human', origin, env };
|
|
179
|
+
const bearer = await (deps.resolveBearer ?? resolveBearer)(bearerArgs);
|
|
177
180
|
if (!bearer.ok) {
|
|
178
181
|
err(`owenloop work approvals: ${bearer.message}`);
|
|
179
182
|
return bearer.code;
|
|
@@ -736,15 +736,17 @@ export function createShiftLoop(opts) {
|
|
|
736
736
|
...live.filter((r) => r.kind === 'agent-run').map((r) => r.run),
|
|
737
737
|
...reserved.filter((r) => r.childKind === 'agent-run').map((r) => r.run),
|
|
738
738
|
]);
|
|
739
|
-
// Resolve which instances to poll.
|
|
739
|
+
// Resolve which instances to poll. Fleet candidates retain their source
|
|
740
|
+
// inbox row so only a proven zero may avoid a targeted observation. An
|
|
741
|
+
// explicit workflow has no inbox row and must always receive one.
|
|
740
742
|
let instances;
|
|
741
743
|
if (opts.workflow !== undefined) {
|
|
742
|
-
instances = [opts.workflow];
|
|
744
|
+
instances = [{ workflow: opts.workflow }];
|
|
743
745
|
}
|
|
744
746
|
else {
|
|
745
747
|
try {
|
|
746
748
|
const inbox = await opts.hub.whatsNext({ serve_capabilities: [...serveCapabilities] });
|
|
747
|
-
instances = (inbox.instances ?? []).map((
|
|
749
|
+
instances = (inbox.instances ?? []).map((inbox) => ({ workflow: inbox.workflow, inbox }));
|
|
748
750
|
}
|
|
749
751
|
catch (e) {
|
|
750
752
|
noteServerBackoff(e);
|
|
@@ -797,13 +799,19 @@ export function createShiftLoop(opts) {
|
|
|
797
799
|
releasedForCapacity = true;
|
|
798
800
|
}
|
|
799
801
|
};
|
|
800
|
-
for (const
|
|
802
|
+
for (const candidate of instances) {
|
|
803
|
+
const wf = candidate.workflow;
|
|
801
804
|
// Skipping means no targeted hub observation happened: leave this
|
|
802
805
|
// workflow out of `polled`/`openRuns` so the work-directory reaper never
|
|
803
806
|
// mistakes damping for an empty response. The inbox call and other
|
|
804
807
|
// workflows remain eligible.
|
|
805
808
|
if (workflowCapacityCooldownActive(wf, remaining, agentRoom))
|
|
806
809
|
continue;
|
|
810
|
+
// Only a numeric zero is authoritative enough to skip. Missing or
|
|
811
|
+
// malformed wire data deliberately falls through to the targeted call.
|
|
812
|
+
// This runs after the cooldown check so a newly ready cooldown is cleared.
|
|
813
|
+
if (candidate.inbox?.eligible === 0)
|
|
814
|
+
continue;
|
|
807
815
|
let res;
|
|
808
816
|
const requestStartedAt = monotonicNow();
|
|
809
817
|
try {
|
|
@@ -3,4 +3,4 @@
|
|
|
3
3
|
* exit 0) and on a dispatch error (to stderr, exit 2). Keeping it in one place
|
|
4
4
|
* means the help output and the error output never drift apart.
|
|
5
5
|
*/
|
|
6
|
-
export declare const USAGE = "owenloop work \u2014 execution-side CLI companion to owenloop\n\nUsage:\n owenloop work hold --order <id> [options] hold an order with a heartbeating lease\n owenloop work exec <order-id> [options] run a command order in a self-leasing loop\n owenloop work agent-run <order-id> [options] host an agent order's step agent in a\n harness, in a self-leasing loop\n owenloop work prepare <workflow> [--origin <url>]\n fetch, cache & normalize step specs\n owenloop work lint <workflow-name | path> lint x.harness option bags in a def\n owenloop work sessions [--all] [--json] list this machine's recorded harness\n sessions and how to re-open them\n owenloop work approvals [--json] every tool call a worker is blocked on\n RIGHT NOW, waiting for a person\n owenloop work approvals approve|deny <wf>/<run> <tool-use-id> [--note <text>]\n answer one; the answer goes back to the\n still-blocked call, not to a later attempt\n owenloop work release --session <id> [options] drain a session's held claims\n owenloop work settings print the resolved settings file\n owenloop work join <code> [--hub <origin>] [--as <account>]\n redeem a join code and store the Scoped\n Identity credential (one-time provisioning)\n\nOptions:\n -h, --help show this help and exit 0\n --version print the owenloop work version and exit 0\n\n root shift options (run as owenloop shift start <crew...> | --all):\n <crew...> serve only these crews (positional, space\n separated); or --all for every crew on the key\n --all serve every crew on the key\n --origin <url> hub origin (else settings.hubOrigin)\n --as <account> Scoped Identity credential account to read + hand\n to dispatched holds/execs (default 'default')\n --name <n> Shift name (default <hostname>/<cwd>)\n --cap <n> max in-flight exec children (default 3)\n --poll-interval <ms> wake poll cadence (default 5000)\n --once bootstrap wake + one sweep, then exit (demo/e2e)\n --max-agents <n> max in-flight agent-run children, separate from\n --cap (default 4; else settings.maxConcurrentAgents)\n\t\t--exec-reserve <n> slots inside --cap that agent-run children may\n\t\t\t\t\tnot occupy, so exec orders always have room\n\t\t\t\t\t(default 1; else settings.execReserve; 0 disables)\n --local-queue-hold <ms> retain an undispatchable claim locally before\n\t\t\t\t\treturning it to the hub (default 0; else\n\t\t\t\t\tsettings.localQueueHoldMs; capped at 90000)\n --cache-dir/--state-dir <p> override the resolved dirs\n\n hold options:\n --order <workflow>/<run> the order to hold (or --order <run> --workflow)\n --workflow <wf> required when --order is a bare run id\n --origin <url> hub origin (else settings.hubOrigin)\n --as <account> Scoped Identity credential account (default\n 'default'; the shift stamps this into born-bound\n holds)\n --session <id> session-holder tag (else env OWENLOOP_SESSION;\n else an anon:<hostname>:<pid> fallback \u2014 a\n holder is always sent)\n --shift <id> dispatching Shift's self-declared id (else\n env OWENLOOP_SHIFT_ID); advisory only\n --heartbeat-interval <ms> lease renew cadence (default 60000)\n --jump-tolerance <ms> wall-gap slack before a tick is treated as a\n clock jump / laptop sleep (default 30000)\n --ignore-stdin don't final-breath on stdin EOF (detached use)\n --never-release another process holds the claim; stop without\n releasing it (agent-run spawns its --mcp child\n this way \u2014 see hold.ts HOLDER OF RECORD)\n --mcp run as a stdio-MCP work-holder: tools get_order /\n submit, lease kept warm underneath (mutually\n exclusive with --ignore-stdin \u2014 stdin is the\n transport)\n\n exec options (usually spawned by shift, not run by hand):\n <workflow>/<run> the command order to run (positional order-id;\n or a bare <run> plus --workflow <wf>)\n --workflow <wf> required when the order-id is a bare run id\n --origin <url> hub origin (else settings.hubOrigin)\n --shift <id> dispatching Shift's self-declared id (else\n env OWENLOOP_SHIFT_ID); advisory only\n --heartbeat-interval <ms> lease renew cadence (default 60000)\n --jump-tolerance <ms> wall-gap slack before a tick is treated as a\n clock jump / laptop sleep (default 30000)\n\n agent-run options (spawned by the shift, not run by hand):\n <workflow>/<run> the agent order to host (positional order-id;\n or a bare <run> plus --workflow <wf>)\n --workflow <wf> required when the order-id is a bare run id\n --origin <url> hub origin (else settings.hubOrigin)\n --harness <id> which registered harness hosts the step agent\n (below a selected roster candidate; else the\n step def's 'harness' field, then the first\n registered one)\n --shift <id> dispatching Shift's self-declared id (else\n env OWENLOOP_SHIFT_ID); advisory only\n --heartbeat-interval <ms> lease renew cadence (default 60000)\n --jump-tolerance <ms> wall-gap slack before a tick is treated as a\n clock jump / laptop sleep (default 30000)\n --submit-grace <ms> after the turn ends, how long to keep asking the\n hub whether the agent's submit landed (default\n 15000). Task completion comes from the HUB, never\n from the harness stream.\n --confirm-interval <ms> poll cadence inside that grace (default 1000)\n\n release options:\n --session <id> session whose claims to drain (else env\n OWENLOOP_SESSION). Agent-held claims re-offer;\n exec-held claims are drain-exempt (B3).\n --origin <url> hub origin (else settings.hubOrigin)\n\n settings (no options in v1):\n prints the resolved settings file path, whether it exists, each known\n knob (hubOrigin, cacheDir, stateDir, dispatchCap, commandRouting,\n maxConcurrentAgents, execReserve, localQueueHoldMs, workRoot, workRepo) with its value + provenance,\n and any unrecognized keys.\n settings.dispatchCap/stateDir are the lowest-precedence\n fallbacks for shift's --cap/--state-dir. NO secrets ever\n live in settings \u2014 credentials stay in owenloop's own store.\n\n sessions options:\n --all include 'dead' sessions (hidden by default \u2014\n a dead session can no longer be resumed)\n --json print the raw newest-per-step records, tokens\n included, instead of the table\n --cache-dir <p> override the resolved cache dir\n\n join options:\n --hub <origin> hub to redeem against (else settings.hubOrigin;\n one of the two is REQUIRED \u2014 the code never\n chooses the hub)\n --as <account> credential account to store under (default:\n the Scoped Identity name the hub returns)\n\n shift/hold/exec/prepare/release env:\n credentials come from owenloop's store \u2014 each role reads the\n agent:<account> slot for its origin (never the human slot); a\n missing slot refuses with a runnable 'owenloop login' command.\n OWENLOOP_ACCOUNT Scoped Identity account for exec/prepare/release\n (default 'default'; shift uses --as, and\n stamps it onto dispatched holds/execs)\n OWENLOOP_TOKEN dev-only bearer override \u2014 when set, used\n verbatim and the store + account are\n bypassed (NOT the primary path)\n OWENLOOP_CACHE_DIR cache root\n OWENLOOP_STATE_DIR shift in-flight state dir\n OWENLOOP_SHIFT_LOG_DIR dir for the shift's shift.log and each\n worker's <run>.log; below --log-dir, above\n settings.shiftLogDir, default the state dir\n OWENLOOP_SHIFT_LOG_MAX_AGE_MS\n how long a worker's <run>.log is kept, in ms;\n below --log-max-age, above\n settings.shiftLogMaxAgeMs, default 14 days.\n Worker logs only \u2014 shift.log is never reaped\n OWENLOOP_SESSION hold session-holder tag / release drain target\n OWENLOOP_SHIFT_ID dispatching Shift's self-declared id for\n hold/exec/agent-run's --shift (advisory\n only, never for auth/routing/dispatch)\n OWENLOOP_WORK_ROOT root for per-RUN agent work dirs\n (<workRoot>/<workflow>/<run>); above\n settings.workRoot, default <cacheDir>/work.\n A hub-supplied OrderPacket.workdir still\n wins, and is never reaped.\n OWENLOOP_WORK_REPO local git repo to cut per-run work dirs from\n as worktrees instead of plain dirs; above\n settings.workRepo, default off\n\n Credentials / accounts:\n owenloop work's RUNTIME roles (shift/hold/exec/prepare/release) are READ-ONLY\n over owenloop's credential store \u2014 they never write credentials. Each\n role reads the agent:<account> slot for its origin (never the human\n slot); the account defaults to 'default'. 'owenloop work join' is the one\n deliberate provisioning-time writer: it stores the Scoped Identity token a hub\n redeem returns via owenloop's public storeCredential, once, at join time\n \u2014 not a runtime write.\n store / connect an account (run owenloop; owenloop work never writes it):\n owenloop login --hub <origin> --as agent:<account>\n (use --as agent for the default account)\n or provision a fresh box from a hub-issued join code:\n owenloop work join <code> --hub <origin>\n select an account at run time:\n --as <account> on shift / hold\n OWENLOOP_ACCOUNT on exec / prepare / release\n (shift resolves once and threads both channels)\n owenloop work does NOT list stored accounts \u2014 enumerating an origin's accounts\n is an owenloop-side capability; check owenloop for which slots are stored.\n\nExit codes:\n 0 success / help / version / lint clean or warnings-only\n 1 runtime failure (fetch/hub error, cache write) / lint found an error\n 2 usage error (unknown or missing role, missing required arg)\n 3 role not implemented yet (skeleton stub \u2014 lands in a later delivery)\n";
|
|
6
|
+
export declare const USAGE: string;
|
|
@@ -15,9 +15,11 @@ Usage:
|
|
|
15
15
|
owenloop work lint <workflow-name | path> lint x.harness option bags in a def
|
|
16
16
|
owenloop work sessions [--all] [--json] list this machine's recorded harness
|
|
17
17
|
sessions and how to re-open them
|
|
18
|
-
owenloop work approvals [--json]
|
|
18
|
+
owenloop work approvals [--origin <url>] [--json]
|
|
19
|
+
${' '.repeat(41)}every tool call a worker is blocked on
|
|
19
20
|
RIGHT NOW, waiting for a person
|
|
20
|
-
owenloop work approvals approve
|
|
21
|
+
owenloop work approvals approve <wf>/<run> <tool-use-id> [--origin <url>] [--note <text>]
|
|
22
|
+
owenloop work approvals deny <wf>/<run> <tool-use-id> [--origin <url>] [--note <text>]
|
|
21
23
|
answer one; the answer goes back to the
|
|
22
24
|
still-blocked call, not to a later attempt
|
|
23
25
|
owenloop work release --session <id> [options] drain a session's held claims
|
|
@@ -128,6 +130,15 @@ Options:
|
|
|
128
130
|
included, instead of the table
|
|
129
131
|
--cache-dir <p> override the resolved cache dir
|
|
130
132
|
|
|
133
|
+
approvals options:
|
|
134
|
+
--origin <url> hub origin (else settings.hubOrigin)
|
|
135
|
+
--json print pending approval rows as JSON (list only)
|
|
136
|
+
--note <text> attach an operator note (approve / deny only)
|
|
137
|
+
credentials list reads the agent:<account> slot selected by
|
|
138
|
+
${' '.repeat(33)}OWENLOOP_ACCOUNT (default 'default'); approve
|
|
139
|
+
${' '.repeat(33)}and deny read the stored human slot instead
|
|
140
|
+
missing human credential run: owenloop login --hub <origin> --as human
|
|
141
|
+
|
|
131
142
|
join options:
|
|
132
143
|
--hub <origin> hub to redeem against (else settings.hubOrigin;
|
|
133
144
|
one of the two is REQUIRED — the code never
|
|
@@ -135,16 +146,23 @@ Options:
|
|
|
135
146
|
--as <account> credential account to store under (default:
|
|
136
147
|
the Scoped Identity name the hub returns)
|
|
137
148
|
|
|
138
|
-
shift/hold/exec/prepare/release env:
|
|
149
|
+
shift/hold/exec/prepare/release and approvals-list env:
|
|
139
150
|
credentials come from owenloop's store — each role reads the
|
|
140
151
|
agent:<account> slot for its origin (never the human slot); a
|
|
141
152
|
missing slot refuses with a runnable 'owenloop login' command.
|
|
153
|
+
${' '.repeat(15)}approvals approve/deny ignore OWENLOOP_ACCOUNT and OWENLOOP_TOKEN,
|
|
154
|
+
${' '.repeat(15)}never mint or log credentials, and refuse with 'owenloop login
|
|
155
|
+
${' '.repeat(15)}--hub <origin> --as human' when the human slot is absent. An
|
|
156
|
+
${' '.repeat(15)}expiring stored human OAuth credential may refresh and persist its
|
|
157
|
+
${' '.repeat(15)}rotation through owenloop's shared credential lock.
|
|
142
158
|
OWENLOOP_ACCOUNT Scoped Identity account for exec/prepare/release
|
|
143
|
-
|
|
144
|
-
|
|
159
|
+
${' '.repeat(38)}and approvals list (default 'default';
|
|
160
|
+
${' '.repeat(38)}shift uses --as, and stamps it onto
|
|
161
|
+
${' '.repeat(38)}dispatched holds/execs)
|
|
145
162
|
OWENLOOP_TOKEN dev-only bearer override — when set, used
|
|
146
163
|
verbatim and the store + account are
|
|
147
|
-
|
|
164
|
+
${' '.repeat(38)}bypassed (NOT the primary path; never for
|
|
165
|
+
${' '.repeat(38)}approvals approve/deny)
|
|
148
166
|
OWENLOOP_CACHE_DIR cache root
|
|
149
167
|
OWENLOOP_STATE_DIR shift in-flight state dir
|
|
150
168
|
OWENLOOP_SHIFT_LOG_DIR dir for the shift's shift.log and each
|
|
@@ -169,13 +187,18 @@ Options:
|
|
|
169
187
|
settings.workRepo, default off
|
|
170
188
|
|
|
171
189
|
Credentials / accounts:
|
|
172
|
-
owenloop work's RUNTIME roles (shift/hold/exec/prepare/release
|
|
173
|
-
over owenloop's credential store — they
|
|
174
|
-
|
|
175
|
-
slot); the account defaults to 'default'.
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
190
|
+
owenloop work's RUNTIME roles (shift/hold/exec/prepare/release and
|
|
191
|
+
approvals list) are READ-ONLY over owenloop's credential store — they
|
|
192
|
+
never write credentials. Each reads the agent:<account> slot for its
|
|
193
|
+
origin (never the human slot); the account defaults to 'default'.
|
|
194
|
+
Approval decisions require the stored human slot rather than an agent
|
|
195
|
+
slot. They never mint or log credentials, but an expiring stored OAuth
|
|
196
|
+
credential may refresh and persist its rotation under the shared lock; if
|
|
197
|
+
the human slot is absent, run:
|
|
198
|
+
${' '.repeat(8)}owenloop login --hub <origin> --as human
|
|
199
|
+
'owenloop work join' is the one deliberate provisioning-time writer: it
|
|
200
|
+
stores the Scoped Identity token a hub redeem returns via owenloop's public
|
|
201
|
+
storeCredential, once, at join time — not a runtime write.
|
|
179
202
|
store / connect an account (run owenloop; owenloop work never writes it):
|
|
180
203
|
owenloop login --hub <origin> --as agent:<account>
|
|
181
204
|
(use --as agent for the default account)
|
|
@@ -183,7 +206,7 @@ Options:
|
|
|
183
206
|
owenloop work join <code> --hub <origin>
|
|
184
207
|
select an account at run time:
|
|
185
208
|
--as <account> on shift / hold
|
|
186
|
-
|
|
209
|
+
${' '.repeat(10)}OWENLOOP_ACCOUNT on exec / prepare / release / approvals list
|
|
187
210
|
(shift resolves once and threads both channels)
|
|
188
211
|
owenloop work does NOT list stored accounts — enumerating an origin's accounts
|
|
189
212
|
is an owenloop-side capability; check owenloop for which slots are stored.
|
package/dist/src/cli.d.ts
CHANGED
|
@@ -210,6 +210,7 @@ export interface HarnessPluginState {
|
|
|
210
210
|
installed: boolean;
|
|
211
211
|
installedVersion: string | null;
|
|
212
212
|
cliVersion: string | null;
|
|
213
|
+
mcpLaunch: McpLaunchState | null;
|
|
213
214
|
}
|
|
214
215
|
/**
|
|
215
216
|
* Resolve a bundled marketplace root from either the source tree (`src/cli.ts`)
|
|
@@ -217,6 +218,11 @@ export interface HarnessPluginState {
|
|
|
217
218
|
* package from producing a path that the harness cannot consume.
|
|
218
219
|
*/
|
|
219
220
|
export declare function resolveBundledMarketplaceRoot(harness: HarnessId): string | null;
|
|
221
|
+
type McpLaunchStatus = 'path' | 'unsafe' | 'unknown';
|
|
222
|
+
interface McpLaunchState {
|
|
223
|
+
status: McpLaunchStatus;
|
|
224
|
+
detail: string;
|
|
225
|
+
}
|
|
220
226
|
/**
|
|
221
227
|
* Async entry point that adds network I/O for `add` and the hub commands on top
|
|
222
228
|
* of the otherwise fully-synchronous engine/CLI (see the doc comment on
|
package/dist/src/cli.js
CHANGED
|
@@ -1281,6 +1281,7 @@ ${' '.repeat(41)}refresh the local hub-rosters cache with an agent credential
|
|
|
1281
1281
|
check <def> [--format text|json] [--max-depth N] [--max-states N] [--max-collection N] [--assume-provided] [--strict-inputs]
|
|
1282
1282
|
bounded reachability check (stall states, true deadlocks, stuck, dead steps, declared invariants)
|
|
1283
1283
|
create <def> [--title t] [--provide name=json ...] [--param k=v ...]
|
|
1284
|
+
${' '.repeat(41)}create a local SQLite workflow instance
|
|
1284
1285
|
provide <wf> <name> [--value json] [--hub <url>] supply an owed (seedOwed) input
|
|
1285
1286
|
adopt <wf> re-pin an instance to the current def (§28); settles new debts
|
|
1286
1287
|
tick <wf> [--now <ms>] [--shallow] [--capability <c>]... pull eligible orders (deep: also from calls: children; --shallow for this instance only; --capability filters to matching-capability steps)
|
|
@@ -1291,7 +1292,7 @@ ${' '.repeat(41)}refresh the local hub-rosters cache with an agent credential
|
|
|
1291
1292
|
status --all every instance's status in one call (fleet read)
|
|
1292
1293
|
wait <wf> --until eligible|done [--timeout <dur>] block until engine state matches
|
|
1293
1294
|
show <wf> dump raw artifacts
|
|
1294
|
-
trace <wf> [--format text] causal timeline + artifact biographies
|
|
1295
|
+
trace <wf> [--format text] local causal timeline + artifact biographies
|
|
1295
1296
|
graph <def-or-wf> [--format dot|mermaid|json] wiring graph (+ live overlay if wf id)
|
|
1296
1297
|
list list workflow instances
|
|
1297
1298
|
green <wf> <run> <path> [--value json] [--terminal]
|
|
@@ -7358,17 +7359,93 @@ function firstOutputLine(value) {
|
|
|
7358
7359
|
const line = value.split(/\r?\n/, 1)[0]?.trim() ?? '';
|
|
7359
7360
|
return line === '' ? null : line;
|
|
7360
7361
|
}
|
|
7361
|
-
function
|
|
7362
|
+
function unknownMcpLaunch(detail) {
|
|
7363
|
+
return { status: 'unknown', detail };
|
|
7364
|
+
}
|
|
7365
|
+
/**
|
|
7366
|
+
* Describe an untrusted plugin launch without echoing manifest values. Plugin
|
|
7367
|
+
* manifests are local user-controlled input, so command/argument strings can
|
|
7368
|
+
* carry credentials even when the declaration is invalid.
|
|
7369
|
+
*/
|
|
7370
|
+
function describeMcpLaunch(command, args) {
|
|
7371
|
+
const commandShape = command === 'owenloop'
|
|
7372
|
+
? '"owenloop"'
|
|
7373
|
+
: command === 'node'
|
|
7374
|
+
? '"node"'
|
|
7375
|
+
: isAbsolute(command)
|
|
7376
|
+
? 'an absolute command'
|
|
7377
|
+
: 'a non-owenloop command';
|
|
7378
|
+
const argsShape = args.length === 1 && args[0] === 'mcp'
|
|
7379
|
+
? 'exactly the "mcp" argument'
|
|
7380
|
+
: args[0] === 'mcp'
|
|
7381
|
+
? `"mcp" plus ${args.length - 1} additional argument(s)`
|
|
7382
|
+
: `${args.length} argument(s) not exactly "mcp"`;
|
|
7383
|
+
return `declares ${commandShape} with ${argsShape}; expected "owenloop" with exactly "mcp" via PATH`;
|
|
7384
|
+
}
|
|
7385
|
+
function classifyMcpLaunch(server, harness, env) {
|
|
7386
|
+
const declaration = recordOf(server);
|
|
7387
|
+
if (declaration === null)
|
|
7388
|
+
return unknownMcpLaunch('the owenloop MCP declaration is missing or malformed');
|
|
7389
|
+
const command = declaration.command;
|
|
7390
|
+
const args = declaration.args;
|
|
7391
|
+
if (typeof command !== 'string' || !Array.isArray(args) || !args.every((arg) => typeof arg === 'string')) {
|
|
7392
|
+
return unknownMcpLaunch('the owenloop MCP command or arguments are missing or malformed');
|
|
7393
|
+
}
|
|
7394
|
+
if (command !== 'owenloop' || args.length !== 1 || args[0] !== 'mcp') {
|
|
7395
|
+
return { status: 'unsafe', detail: describeMcpLaunch(command, args) };
|
|
7396
|
+
}
|
|
7397
|
+
if (harness === 'codex') {
|
|
7398
|
+
const envVars = declaration.env_vars;
|
|
7399
|
+
if (!Array.isArray(envVars) || !envVars.includes('PATH')) {
|
|
7400
|
+
return { status: 'unsafe', detail: 'declares "owenloop" "mcp" but does not pass PATH to the MCP subprocess' };
|
|
7401
|
+
}
|
|
7402
|
+
}
|
|
7403
|
+
if (!commandOnPath(env, 'owenloop')) {
|
|
7404
|
+
return { status: 'unsafe', detail: 'declares "owenloop" "mcp" but owenloop is not executable on PATH' };
|
|
7405
|
+
}
|
|
7406
|
+
return { status: 'path', detail: 'MCP resolves as owenloop mcp via PATH' };
|
|
7407
|
+
}
|
|
7408
|
+
function mcpLaunchFromManifest(pluginRoot, harness, env, rootName) {
|
|
7409
|
+
if (typeof pluginRoot !== 'string' || pluginRoot.trim() === '') {
|
|
7410
|
+
return unknownMcpLaunch(`${rootName} was not reported by the harness`);
|
|
7411
|
+
}
|
|
7412
|
+
try {
|
|
7413
|
+
const manifest = recordOf(JSON.parse(readFileSync(join(pluginRoot, '.mcp.json'), 'utf8')));
|
|
7414
|
+
const servers = recordOf(manifest?.mcpServers);
|
|
7415
|
+
if (servers === null || !Object.hasOwn(servers, 'owenloop')) {
|
|
7416
|
+
return unknownMcpLaunch(`${rootName}/.mcp.json does not declare mcpServers.owenloop`);
|
|
7417
|
+
}
|
|
7418
|
+
return classifyMcpLaunch(servers.owenloop, harness, env);
|
|
7419
|
+
}
|
|
7420
|
+
catch {
|
|
7421
|
+
return unknownMcpLaunch(`could not read ${rootName}/.mcp.json`);
|
|
7422
|
+
}
|
|
7423
|
+
}
|
|
7424
|
+
function mcpLaunchFromPluginEntry(entry, harness, env) {
|
|
7425
|
+
if (harness === 'claude-code') {
|
|
7426
|
+
if (Object.hasOwn(entry, 'mcpServers')) {
|
|
7427
|
+
const servers = recordOf(entry.mcpServers);
|
|
7428
|
+
if (servers === null)
|
|
7429
|
+
return unknownMcpLaunch('the inline mcpServers data is malformed');
|
|
7430
|
+
if (Object.hasOwn(servers, 'owenloop'))
|
|
7431
|
+
return classifyMcpLaunch(servers.owenloop, harness, env);
|
|
7432
|
+
}
|
|
7433
|
+
return mcpLaunchFromManifest(entry.installPath, harness, env, 'installPath');
|
|
7434
|
+
}
|
|
7435
|
+
const source = recordOf(entry.source);
|
|
7436
|
+
return mcpLaunchFromManifest(source?.path, harness, env, 'source.path');
|
|
7437
|
+
}
|
|
7438
|
+
function parsePluginList(stdout, harness, env) {
|
|
7362
7439
|
let parsed;
|
|
7363
7440
|
try {
|
|
7364
7441
|
parsed = JSON.parse(stdout);
|
|
7365
7442
|
}
|
|
7366
7443
|
catch {
|
|
7367
|
-
return { known: false, installed: false, installedVersion: null };
|
|
7444
|
+
return { known: false, installed: false, installedVersion: null, mcpLaunch: null };
|
|
7368
7445
|
}
|
|
7369
7446
|
if (harness === 'claude-code') {
|
|
7370
7447
|
if (!Array.isArray(parsed))
|
|
7371
|
-
return { known: false, installed: false, installedVersion: null };
|
|
7448
|
+
return { known: false, installed: false, installedVersion: null, mcpLaunch: null };
|
|
7372
7449
|
const entry = parsed.find((item) => {
|
|
7373
7450
|
const row = recordOf(item);
|
|
7374
7451
|
if (row === null)
|
|
@@ -7377,12 +7454,18 @@ function parsePluginList(stdout, harness) {
|
|
|
7377
7454
|
return id === PLUGIN_SELECTOR || id.split('@', 1)[0] === 'owenloop';
|
|
7378
7455
|
});
|
|
7379
7456
|
return entry === undefined
|
|
7380
|
-
? { known: true, installed: false, installedVersion: null }
|
|
7381
|
-
: {
|
|
7457
|
+
? { known: true, installed: false, installedVersion: null, mcpLaunch: null }
|
|
7458
|
+
: {
|
|
7459
|
+
known: true,
|
|
7460
|
+
installed: true,
|
|
7461
|
+
installedVersion: normalizedPluginVersion(entry.version),
|
|
7462
|
+
mcpLaunch: mcpLaunchFromPluginEntry(entry, harness, env),
|
|
7463
|
+
};
|
|
7382
7464
|
}
|
|
7383
7465
|
const root = recordOf(parsed);
|
|
7384
|
-
if (root === null || !Array.isArray(root.installed))
|
|
7385
|
-
return { known: false, installed: false, installedVersion: null };
|
|
7466
|
+
if (root === null || !Array.isArray(root.installed)) {
|
|
7467
|
+
return { known: false, installed: false, installedVersion: null, mcpLaunch: null };
|
|
7468
|
+
}
|
|
7386
7469
|
const entry = root.installed.find((item) => {
|
|
7387
7470
|
const row = recordOf(item);
|
|
7388
7471
|
if (row === null || row.installed !== true)
|
|
@@ -7391,8 +7474,13 @@ function parsePluginList(stdout, harness) {
|
|
|
7391
7474
|
(row.name === 'owenloop' && row.marketplaceName === 'owenloop'));
|
|
7392
7475
|
});
|
|
7393
7476
|
return entry === undefined
|
|
7394
|
-
? { known: true, installed: false, installedVersion: null }
|
|
7395
|
-
: {
|
|
7477
|
+
? { known: true, installed: false, installedVersion: null, mcpLaunch: null }
|
|
7478
|
+
: {
|
|
7479
|
+
known: true,
|
|
7480
|
+
installed: true,
|
|
7481
|
+
installedVersion: normalizedPluginVersion(entry.version),
|
|
7482
|
+
mcpLaunch: mcpLaunchFromPluginEntry(entry, harness, env),
|
|
7483
|
+
};
|
|
7396
7484
|
}
|
|
7397
7485
|
function probeCliVersion(run, cliName) {
|
|
7398
7486
|
try {
|
|
@@ -7410,24 +7498,35 @@ function probePlugin(io) {
|
|
|
7410
7498
|
const config = HARNESS_CONFIGS[id];
|
|
7411
7499
|
const cliFound = commandOnPath(io.env, config.cliName);
|
|
7412
7500
|
if (!cliFound) {
|
|
7413
|
-
return {
|
|
7501
|
+
return {
|
|
7502
|
+
id,
|
|
7503
|
+
cliName: config.cliName,
|
|
7504
|
+
cliFound: false,
|
|
7505
|
+
installed: false,
|
|
7506
|
+
installedVersion: null,
|
|
7507
|
+
cliVersion: null,
|
|
7508
|
+
mcpLaunch: null,
|
|
7509
|
+
};
|
|
7414
7510
|
}
|
|
7415
7511
|
let installed = false;
|
|
7416
7512
|
let installedVersion = null;
|
|
7513
|
+
let mcpLaunch = null;
|
|
7417
7514
|
try {
|
|
7418
7515
|
const result = run(config.cliName, ['plugin', 'list', '--json']);
|
|
7419
7516
|
if (result.status === 0) {
|
|
7420
|
-
const parsed = parsePluginList(result.stdout, id);
|
|
7517
|
+
const parsed = parsePluginList(result.stdout, id, io.env);
|
|
7421
7518
|
// A successful command with malformed output cannot establish presence.
|
|
7422
7519
|
// Treat it as not installed, matching the non-zero-exit path below.
|
|
7423
7520
|
installed = parsed.known ? parsed.installed : false;
|
|
7424
7521
|
installedVersion = parsed.installedVersion;
|
|
7522
|
+
mcpLaunch = parsed.mcpLaunch;
|
|
7425
7523
|
}
|
|
7426
7524
|
}
|
|
7427
7525
|
catch {
|
|
7428
7526
|
// A failed probe cannot establish presence; the ACT remains PATH-gated.
|
|
7429
7527
|
installed = false;
|
|
7430
7528
|
installedVersion = null;
|
|
7529
|
+
mcpLaunch = null;
|
|
7431
7530
|
}
|
|
7432
7531
|
return {
|
|
7433
7532
|
id,
|
|
@@ -7436,6 +7535,7 @@ function probePlugin(io) {
|
|
|
7436
7535
|
installed,
|
|
7437
7536
|
installedVersion,
|
|
7438
7537
|
cliVersion: probeCliVersion(run, config.cliName),
|
|
7538
|
+
mcpLaunch,
|
|
7439
7539
|
};
|
|
7440
7540
|
});
|
|
7441
7541
|
}
|
|
@@ -7531,7 +7631,7 @@ function installPluginStep(io, state) {
|
|
|
7531
7631
|
}
|
|
7532
7632
|
const expectedVersion = packageVersion().trim();
|
|
7533
7633
|
const currentVersion = state.installedVersion?.trim() ?? null;
|
|
7534
|
-
if (state.installed && currentVersion === expectedVersion) {
|
|
7634
|
+
if (state.installed && currentVersion === expectedVersion && state.mcpLaunch?.status !== 'unsafe') {
|
|
7535
7635
|
return { action: 'skipped', detail: `owenloop ${currentVersion} already current` };
|
|
7536
7636
|
}
|
|
7537
7637
|
const root = resolvedMarketplaceRoot(io, state.id);
|
|
@@ -8191,14 +8291,29 @@ async function runDoctor(io, origin) {
|
|
|
8191
8291
|
const cliVersion = pluginState.cliVersion ?? 'unknown';
|
|
8192
8292
|
record(`plugin (${pluginState.id})`, false, `not installed — ${pluginRemedy(pluginState.id, root)} · ${config.cliName} ${cliVersion}`, PLUGIN_CHECK_FATAL);
|
|
8193
8293
|
}
|
|
8194
|
-
else if (pluginState.installedVersion === null) {
|
|
8195
|
-
record(`plugin (${pluginState.id})`, true, `owenloop version unknown · ${config.cliName} ${pluginState.cliVersion ?? 'unknown'}`, PLUGIN_CHECK_FATAL);
|
|
8196
|
-
}
|
|
8197
|
-
else if (pluginState.installedVersion === packageVersion().trim()) {
|
|
8198
|
-
record(`plugin (${pluginState.id})`, true, `owenloop ${pluginState.installedVersion} · ${config.cliName} ${pluginState.cliVersion ?? 'unknown'}`, PLUGIN_CHECK_FATAL);
|
|
8199
|
-
}
|
|
8200
8294
|
else {
|
|
8201
|
-
|
|
8295
|
+
const launch = pluginState.mcpLaunch ?? unknownMcpLaunch('the effective MCP launch was not reported');
|
|
8296
|
+
const expectedVersion = packageVersion().trim();
|
|
8297
|
+
const findings = [];
|
|
8298
|
+
if (launch.status === 'unsafe') {
|
|
8299
|
+
findings.push(`MCP launch drift: ${launch.detail} — run owenloop setup`);
|
|
8300
|
+
}
|
|
8301
|
+
else if (launch.status === 'unknown') {
|
|
8302
|
+
findings.push(`MCP launch unverifiable: ${launch.detail} — run owenloop setup`);
|
|
8303
|
+
}
|
|
8304
|
+
if (pluginState.installedVersion !== null && pluginState.installedVersion !== expectedVersion) {
|
|
8305
|
+
findings.push(`owenloop ${pluginState.installedVersion} but CLI is ${expectedVersion} — run owenloop setup`);
|
|
8306
|
+
}
|
|
8307
|
+
const cliVersion = `${config.cliName} ${pluginState.cliVersion ?? 'unknown'}`;
|
|
8308
|
+
if (findings.length > 0) {
|
|
8309
|
+
record(`plugin (${pluginState.id})`, false, `${findings.join(' · ')} · ${cliVersion}`, PLUGIN_CHECK_FATAL);
|
|
8310
|
+
}
|
|
8311
|
+
else if (pluginState.installedVersion === null) {
|
|
8312
|
+
record(`plugin (${pluginState.id})`, true, `owenloop version unknown · ${launch.detail} · ${cliVersion}`, PLUGIN_CHECK_FATAL);
|
|
8313
|
+
}
|
|
8314
|
+
else {
|
|
8315
|
+
record(`plugin (${pluginState.id})`, true, `owenloop ${pluginState.installedVersion} · ${launch.detail} · ${cliVersion}`, PLUGIN_CHECK_FATAL);
|
|
8316
|
+
}
|
|
8202
8317
|
}
|
|
8203
8318
|
}
|
|
8204
8319
|
return { ok: coreOk, checks };
|
package/docs/agent-runner.md
CHANGED
|
@@ -6,6 +6,20 @@ The runtime worker resolves the verified workflow definition from the local work
|
|
|
6
6
|
|
|
7
7
|
Runtime preflight is authoritative. `owenloop work lint` runs the same common and adapter checks for author feedback, but lint cannot account for a later `--harness` override or a selected crew-roster candidate.
|
|
8
8
|
|
|
9
|
+
## Capability-silent steps
|
|
10
|
+
|
|
11
|
+
A step with no declared capabilities is valid loud-proceed work: no crew roster
|
|
12
|
+
model or effort is injected. An authored `x.harness.model` or
|
|
13
|
+
`x.harness.effort` still applies; only when neither is authored does the
|
|
14
|
+
selected harness choose its own default. The worker emits a
|
|
15
|
+
`CAPABILITY-SILENT` claim-time warning that names the selected harness and
|
|
16
|
+
which policy applies. If the turn ends without a hub outcome, its
|
|
17
|
+
terminal local line repeats the provider-reported runtime model and a bounded
|
|
18
|
+
harness diagnostic when either was reported; missing values are named rather
|
|
19
|
+
than guessed. These messages are telemetry only. The hub remains the sole
|
|
20
|
+
source of task outcome, and the targeted release request carries no diagnostic
|
|
21
|
+
fields.
|
|
22
|
+
|
|
9
23
|
Native judge entries do not carry a separately authored `x` map. The definition
|
|
10
24
|
compiler deep-clones the producer step's complete parsed `x` map onto every
|
|
11
25
|
synthesized judge step, and generated and persisted judge orders expose that
|
|
@@ -92,9 +106,9 @@ The vendor classifiers do not, in practice, consult anyone. The SDK's `auto` mod
|
|
|
92
106
|
|
|
93
107
|
The Claude Code adapter therefore does not delegate `auto-safe` to `auto`. Both `ask` and `auto-safe` translate to `default`, the one SDK mode that routes every unapproved tool call to `canUseTool`, and the adapter's own gatekeeper decides:
|
|
94
108
|
|
|
95
|
-
- **Path containment.** A tool call naming a path outside the step's working directory escalates
|
|
109
|
+
- **Path containment.** A tool call naming a path outside the step's working directory escalates under either policy, except when both the step explicitly declares `filesystem: unrestricted` and the call is one of the shared audited filesystem readers: `Read`, `Glob`, or `Grep`. A harness-reported `blockedPath` remains authoritative, and writes, non-read tools, and calls with narrower or omitted filesystem declarations remain workdir-contained. This is decidable and is the check that catches the probes above.
|
|
96
110
|
- **A shell deny-list.** Under `auto-safe`, `Bash` escalates on a short list of destructive or exfiltrating patterns (`sudo`, recursive force-delete, device writes, ownership changes, `curl`/`wget` carrying a request body, changes to what runs on the machine outside the step). It is a deny-list, not a proof: an obfuscated command gets past it. A step whose every command must be reviewed says `ask`, which escalates all of them without consulting the list.
|
|
97
|
-
- **Policy.** `ask` allows
|
|
111
|
+
- **Policy.** `ask` allows a declared-safe filesystem read: normally that means a contained read, while an explicitly unrestricted filesystem also permits the audited `Read`/`Glob`/`Grep` exception above. It still escalates writes, network readers, and every other operation. `auto-safe` allows ordinary work and escalates what the two checks above establish. The worker-owned `owenloop` MCP mount is allowed under both, because gating it would remove a stuck step's ability to say so.
|
|
98
112
|
|
|
99
113
|
An escalation in a Shift-dispatched run cannot be a synchronous prompt — no person is watching at the moment of the call, and a call left waiting is a stall that re-arms the step into a retry storm. The adapter denies the call and routes the agent to the `ask` MCP tool, which freezes the owed artifact, closes the run without burning further attempts, and puts the question on a human's attention feed with an answer path back into the next attempt. The denial is also emitted as a progress event, so an operator can see a gate that fired.
|
|
100
114
|
|