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.
@@ -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 and bearer resolve exactly as in `release`: `--origin` → settings
43
- * `hubOrigin`, and the `agent:<account>` credential slot for `OWENLOOP_ACCOUNT`
44
- * (default `default`). The hub refuses `answer_approval` to an agent token by
45
- * design — this verb is for a person's key.
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 and bearer resolve exactly as in `release`: `--origin` → settings
43
- * `hubOrigin`, and the `agent:<account>` credential slot for `OWENLOOP_ACCOUNT`
44
- * (default `default`). The hub refuses `answer_approval` to an agent token by
45
- * design — this verb is for a person's key.
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 account = env['OWENLOOP_ACCOUNT'] ?? 'default';
176
- const bearer = await resolveBearer({ origin, account, env });
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((i) => i.workflow);
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 wf of instances) {
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] every tool call a worker is blocked on
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|deny <wf>/<run> <tool-use-id> [--note <text>]
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
- (default 'default'; shift uses --as, and
144
- stamps it onto dispatched holds/execs)
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
- bypassed (NOT the primary path)
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) are READ-ONLY
173
- over owenloop's credential store — they never write credentials. Each
174
- role reads the agent:<account> slot for its origin (never the human
175
- slot); the account defaults to 'default'. 'owenloop work join' is the one
176
- deliberate provisioning-time writer: it stores the Scoped Identity token a hub
177
- redeem returns via owenloop's public storeCredential, once, at join time
178
- — not a runtime write.
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
- OWENLOOP_ACCOUNT on exec / prepare / release
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 parsePluginList(stdout, harness) {
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
- : { known: true, installed: true, installedVersion: normalizedPluginVersion(entry.version) };
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
- : { known: true, installed: true, installedVersion: normalizedPluginVersion(entry.version) };
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 { id, cliName: config.cliName, cliFound: false, installed: false, installedVersion: null, cliVersion: null };
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
- record(`plugin (${pluginState.id})`, false, `owenloop ${pluginState.installedVersion} but CLI is ${packageVersion().trim()} — run owenloop setup · ${config.cliName} ${pluginState.cliVersion ?? 'unknown'}`, PLUGIN_CHECK_FATAL);
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 };
@@ -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, under either policy. This is decidable and is the check that catches the probes above.
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 only a contained read and escalates everything else. `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.
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