@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.10

package/dist/runtime/commands/config.js

@@ -4,7 +4,9 @@ import { dirname, resolve } from 'node:path';
 import { z } from 'zod';
 import { loadMcpRegistry } from '../../core/mcp/registry.js';
 import { listMcpTrust, setMcpTrust, } from '../../core/mcp/trust.js';
+import { request } from 'undici';
 import { trustWorkspace } from '../../core/trust.js';
+import { resolveActiveCredential } from '../../core/credentials.js';
 /**
  * `pugi config` — operator-level configuration surface.
  *
@@ -53,24 +55,90 @@ export async function runConfigCommand(args, ctx) {
                 'pugi config mcp trust <name>',
                 'pugi config mcp deny <name>',
                 'pugi config mcp list',
+                'pugi config get routing',
+                'pugi config set routing.<tag>.<budget>=<model>',
+                'pugi config unset routing.<tag>.<budget>',
+                'pugi config get privacy',
+                'pugi config set privacy=strict|balanced|permissive',
             ],
         }, [
             'Usage:',
-            '  pugi config get <key>            Read a config value.',
-            '  pugi config set <key> <value>    Write a config value.',
-            '  pugi config list                 Show all config values.',
-            '  pugi config trust .              Trust the current workspace for hooks + MCP.',
-            '  pugi config mcp trust <name>     Mark an MCP server as trusted.',
-            '  pugi config mcp deny <name>      Block an MCP server.',
-            '  pugi config mcp list             Show declared MCP servers + trust state.',
+            '  pugi config get <key>                            Read a config value.',
+            '  pugi config set <key> <value>                    Write a config value.',
+            '  pugi config list                                 Show all config values.',
+            '  pugi config trust .                              Trust the current workspace for hooks + MCP.',
+            '  pugi config mcp trust <name>                     Mark an MCP server as trusted.',
+            '  pugi config mcp deny <name>                      Block an MCP server.',
+            '  pugi config mcp list                             Show declared MCP servers + trust state.',
+            '  pugi config get routing                          Show effective routing table (defaults + tenant overrides).',
+            '  pugi config set routing.<tag>.<budget>=<model>   Override the model for one (tag, budget) lane.',
+            '  pugi config unset routing.<tag>.<budget>         Remove a routing override (revert to default).',
+            '  pugi config get privacy                          Show current tenant privacy mode + last-flip metadata.',
+            '  pugi config set privacy=<mode>                   Flip privacy mode (strict | balanced | permissive).',
         ].join('\n'));
         return;
     }
     switch (sub) {
         case 'get':
+            // Special form: `pugi config get routing` hits the admin-api surface,
+            // not the local config file. Anything else is a local-config read.
+            if (args[1] === 'routing') {
+                return runRoutingGet(ctx);
+            }
+            // alpha 6.13: `pugi config get privacy` hits the admin-api
+            // /api/admin/privacy/mode surface. The privacy mode is a tenant-
+            // scoped server-side setting (so the Anvil filter can enforce it),
+            // not a local-only preference.
+            if (args[1] === 'privacy') {
+                return runPrivacyGet(ctx);
+            }
             return runConfigGet(args.slice(1), ctx);
         case 'set':
+            // Special form: `pugi config set routing.<tag>.<budget>=<model>` hits
+            // the admin-api routing override surface.
+            if (args[1] && args[1].startsWith('routing.')) {
+                return runRoutingSet(args.slice(1), ctx);
+            }
+            // alpha 6.13: `pugi config set privacy=<mode>` (or `privacy <mode>`)
+            // flips the tenant-scoped server-side mode IFF <mode> is one of
+            // the new closed set (strict | balanced | permissive). Legacy
+            // values (local-only | metadata | full) still hit the local
+            // config schema via runConfigSet so existing operators do not
+            // get a surprise 4xx when their playbook still uses the old
+            // names. The unit spec for config.ts has a regression test for
+            // both code paths.
+            //
+            // Triple-review P2 fix (2026-05-25): the prior disambiguation
+            // only excluded the bare form (`privacy local-only`) - the `=`
+            // form (`privacy=local-only`) still routed to runPrivacySet and
+            // 4xx'd. We now check the value AFTER `=` and route legacy local
+            // values to runConfigSet; new-style values + unknown values
+            // continue to runPrivacySet so its client-side validator surfaces
+            // a structured "Unknown privacy mode" error (preserves the
+            // existing UX for typos like `privacy=paranoid`).
+            if (args[1]) {
+                const equalsForm = args[1].startsWith('privacy=');
+                const bareForm = args[1] === 'privacy';
+                if (equalsForm) {
+                    const valueAfterEquals = args[1].slice('privacy='.length);
+                    if (isLegacyLocalPrivacyValue(valueAfterEquals)) {
+                        // Legacy local form (`privacy=local-only|metadata|full`) -
+                        // split into `['privacy', '<value>']` so runConfigSet sees
+                        // the same shape it would for the bare form.
+                        return runConfigSet(['privacy', valueAfterEquals], ctx);
+                    }
+                    return runPrivacySet(args.slice(1), ctx);
+                }
+                if (bareForm && isNewPrivacyModeValue(args[2])) {
+                    return runPrivacySet(args.slice(1), ctx);
+                }
+            }
             return runConfigSet(args.slice(1), ctx);
+        case 'unset':
+            if (args[1] && args[1].startsWith('routing.')) {
+                return runRoutingUnset(args.slice(1), ctx);
+            }
+            throw new Error(`Unknown sub-command "pugi config unset ${args[1] ?? ''}". Only routing.<tag>.<budget> is supported today.`);
         case 'list':
             return runConfigList(ctx);
         case 'trust':
@@ -78,7 +146,7 @@ export async function runConfigCommand(args, ctx) {
         case 'mcp':
             return runConfigMcp(args.slice(1), ctx);
         default:
-            throw new Error(`Unknown sub-command "pugi config ${sub}". Expected get, set, list, trust, or mcp.`);
+            throw new Error(`Unknown sub-command "pugi config ${sub}". Expected get, set, unset, list, trust, or mcp.`);
     }
 }
 function configPath() {
@@ -228,4 +296,266 @@ async function runConfigMcpFlip(args, ctx, state) {
         ? `MCP server "${name}" is now trusted.`
         : `MCP server "${name}" is now denied.`);
 }
+/* ------------------------------------------------------------------ */
+/* α6.10 multi-model routing — config.routing.* subcommands            */
+/* ------------------------------------------------------------------ */
+/**
+ * Closed sets — match
+ * `apps/admin-api/src/mira/routing/dispatch-tag.ts` verbatim. Pinning
+ * them in the CLI lets us reject typos client-side before round-tripping
+ * to the admin-api (better UX, smaller blast radius for a wrong typo on
+ * a flaky network).
+ */
+const ROUTING_TAGS = [
+    'classify',
+    'reason',
+    'codegen',
+    'summarize',
+    'vision',
+    'embed',
+];
+const ROUTING_BUDGETS = ['min', 'std', 'max'];
+function isRoutingTag(value) {
+    return ROUTING_TAGS.includes(value);
+}
+function isRoutingBudget(value) {
+    return ROUTING_BUDGETS.includes(value);
+}
+/**
+ * Resolve the admin-api host + bearer token from the CLI credential
+ * store. Throws a structured "anonymous" error when the operator has
+ * not logged in — same shape as `pugi whoami` so the harness exit
+ * codes stay aligned.
+ */
+function resolveAdminApi() {
+    const credential = resolveActiveCredential();
+    if (!credential) {
+        throw new Error('pugi config routing requires authentication. Run `pugi login` first.');
+    }
+    return { apiUrl: credential.apiUrl, apiKey: credential.apiKey };
+}
+/**
+ * `pugi config get routing` — fetch the static default table + the
+ * tenant's override table, merge, and render as `routing.<tag>.<budget> = <model>`.
+ * Shows which lanes are overridden vs default.
+ */
+async function runRoutingGet(ctx) {
+    const { apiUrl, apiKey } = resolveAdminApi();
+    const [defaults, overrides] = await Promise.all([
+        fetchJson(`${apiUrl}/api/admin/model-routing/defaults`, apiKey),
+        fetchJson(`${apiUrl}/api/admin/model-routing/overrides`, apiKey),
+    ]);
+    const overrideMap = new Map();
+    for (const row of overrides.overrides) {
+        overrideMap.set(`${row.tag}.${row.budgetHint}`, row.model);
+    }
+    const cells = defaults.defaults.map((cell) => {
+        const overridden = overrideMap.get(`${cell.tag}.${cell.budgetHint}`);
+        return {
+            tag: cell.tag,
+            budgetHint: cell.budgetHint,
+            model: overridden ?? cell.model,
+            source: overridden ? 'override' : 'default',
+        };
+    });
+    const text = [
+        'Routing table (effective = override | default):',
+        ...cells.map((cell) => `  routing.${cell.tag.padEnd(10)}.${cell.budgetHint.padEnd(3)} = ${cell.model.padEnd(28)} (${cell.source})`),
+    ].join('\n');
+    ctx.writeOutput({
+        command: 'config.routing.get',
+        apiUrl,
+        cells,
+    }, text);
+}
+/**
+ * `pugi config set routing.<tag>.<budget>=<model>` — PUT to the admin-api
+ * override surface. Validates tag + budget client-side before round-tripping
+ * so a typo fails fast.
+ */
+async function runRoutingSet(args, ctx) {
+    // The original arg is `routing.<tag>.<budget>=<model>` — args[0] holds
+    // everything up to the first whitespace, but the value may have been
+    // split. Re-join and re-split on `=` to be robust against a
+    // model slug containing `/` or `-`.
+    const raw = args.join(' ').trim();
+    const eqIdx = raw.indexOf('=');
+    if (eqIdx === -1) {
+        throw new Error('pugi config set routing.<tag>.<budget>=<model> requires an =<model> suffix.');
+    }
+    const lhs = raw.slice(0, eqIdx).trim();
+    const value = raw.slice(eqIdx + 1).trim();
+    const lhsParts = lhs.split('.');
+    if (lhsParts.length !== 3 || lhsParts[0] !== 'routing') {
+        throw new Error(`Expected routing.<tag>.<budget>, got "${lhs}".`);
+    }
+    const tag = lhsParts[1] ?? '';
+    const budget = lhsParts[2] ?? '';
+    if (!isRoutingTag(tag)) {
+        throw new Error(`Unknown routing tag "${tag}". Allowed: ${ROUTING_TAGS.join(', ')}.`);
+    }
+    if (!isRoutingBudget(budget)) {
+        throw new Error(`Unknown routing budget "${budget}". Allowed: ${ROUTING_BUDGETS.join(', ')}.`);
+    }
+    if (value.length === 0) {
+        throw new Error('Model slug must be non-empty.');
+    }
+    const { apiUrl, apiKey } = resolveAdminApi();
+    await fetchJson(`${apiUrl}/api/admin/model-routing/overrides/${tag}/${budget}`, apiKey, { method: 'PUT', body: { model: value } });
+    ctx.writeOutput({
+        command: 'config.routing.set',
+        tag,
+        budget,
+        model: value,
+    }, `routing.${tag}.${budget} = ${value}`);
+}
+/**
+ * `pugi config unset routing.<tag>.<budget>` — DELETE the override and
+ * revert the lane to its static default. Idempotent.
+ */
+async function runRoutingUnset(args, ctx) {
+    const lhs = (args[0] ?? '').trim();
+    const lhsParts = lhs.split('.');
+    if (lhsParts.length !== 3 || lhsParts[0] !== 'routing') {
+        throw new Error(`Expected routing.<tag>.<budget>, got "${lhs}".`);
+    }
+    const tag = lhsParts[1] ?? '';
+    const budget = lhsParts[2] ?? '';
+    if (!isRoutingTag(tag)) {
+        throw new Error(`Unknown routing tag "${tag}". Allowed: ${ROUTING_TAGS.join(', ')}.`);
+    }
+    if (!isRoutingBudget(budget)) {
+        throw new Error(`Unknown routing budget "${budget}". Allowed: ${ROUTING_BUDGETS.join(', ')}.`);
+    }
+    const { apiUrl, apiKey } = resolveAdminApi();
+    const result = await fetchJson(`${apiUrl}/api/admin/model-routing/overrides/${tag}/${budget}`, apiKey, { method: 'DELETE' });
+    ctx.writeOutput({
+        command: 'config.routing.unset',
+        tag,
+        budget,
+        removed: result.removed,
+    }, result.removed
+        ? `routing.${tag}.${budget} reverted to default.`
+        : `routing.${tag}.${budget} had no override (nothing to remove).`);
+}
+/* ------------------------------------------------------------------ */
+/* alpha 6.13 privacy 3-mode - config.privacy.* subcommands             */
+/* ------------------------------------------------------------------ */
+/**
+ * Closed mirror of the server-side PRIVACY_MODES enum
+ * (apps/admin-api/src/privacy/privacy-mode.ts). Pinning the literal
+ * set here lets the CLI reject typos client-side before the round-
+ * trip to admin-api (better UX, smaller blast radius on a flaky
+ * network).
+ */
+const PRIVACY_MODES = ['strict', 'balanced', 'permissive'];
+function isNewPrivacyModeValue(value) {
+    return typeof value === 'string' && PRIVACY_MODES.includes(value);
+}
+function isPrivacyMode(value) {
+    return PRIVACY_MODES.includes(value);
+}
+/**
+ * Legacy local-config privacy values from before alpha 6.13. Kept so
+ * `pugi config set privacy=local-only` continues to write to the local
+ * config file (matching the bare-form behaviour). Triple-review P2 fix
+ * (2026-05-25): the prior disambiguation only excluded the bare form;
+ * the `=` form routed to runPrivacySet and 4xx'd on the unknown mode.
+ */
+const LEGACY_LOCAL_PRIVACY_VALUES = [
+    'local-only',
+    'metadata',
+    'full',
+];
+function isLegacyLocalPrivacyValue(value) {
+    return (typeof value === 'string' &&
+        LEGACY_LOCAL_PRIVACY_VALUES.includes(value));
+}
+/**
+ * `pugi config get privacy` - fetch the current privacy mode snapshot
+ * from /api/admin/privacy/mode + render it in human-readable form.
+ */
+async function runPrivacyGet(ctx) {
+    const { apiUrl, apiKey } = resolveAdminApi();
+    const snapshot = await fetchJson(`${apiUrl}/api/admin/privacy/mode`, apiKey);
+    const lastUpdatedLine = snapshot.lastUpdated
+        ? `(last set by ${snapshot.lastUpdatedBy ?? 'unknown'} on ${snapshot.lastUpdated})`
+        : '(no flips recorded; on implicit default)';
+    const text = [
+        `privacy.mode = ${snapshot.mode}`,
+        `privacy.defaultMode = ${snapshot.defaultMode}`,
+        lastUpdatedLine,
+    ].join('\n');
+    ctx.writeOutput({
+        command: 'config.privacy.get',
+        apiUrl,
+        snapshot,
+    }, text);
+}
+/**
+ * `pugi config set privacy=<mode>` - PUT to /api/admin/privacy/mode.
+ * Validates the mode client-side against the closed set before
+ * round-tripping.
+ *
+ * Accepts both `privacy <mode>` and `privacy=<mode>` argument forms so
+ * the operator can type it either way.
+ */
+async function runPrivacySet(args, ctx) {
+    const raw = args.join(' ').trim();
+    let mode;
+    if (raw.startsWith('privacy=')) {
+        mode = raw.slice('privacy='.length).trim();
+    }
+    else if (raw === 'privacy') {
+        throw new Error('pugi config set privacy requires a mode. Try: pugi config set privacy=balanced');
+    }
+    else if (raw.startsWith('privacy ')) {
+        mode = raw.slice('privacy '.length).trim();
+    }
+    else {
+        throw new Error(`pugi config set privacy: unrecognised argument "${raw}". Try: pugi config set privacy=balanced`);
+    }
+    if (mode.length === 0) {
+        throw new Error('pugi config set privacy requires a mode. Try: pugi config set privacy=balanced');
+    }
+    if (!isPrivacyMode(mode)) {
+        throw new Error(`Unknown privacy mode "${mode}". Allowed: ${PRIVACY_MODES.join(', ')}.`);
+    }
+    const { apiUrl, apiKey } = resolveAdminApi();
+    const snapshot = await fetchJson(`${apiUrl}/api/admin/privacy/mode`, apiKey, { method: 'PUT', body: { mode } });
+    ctx.writeOutput({
+        command: 'config.privacy.set',
+        mode: snapshot.mode,
+        snapshot,
+    }, `privacy.mode = ${snapshot.mode}`);
+}
+/**
+ * Thin authenticated fetch helper. Adds the bearer token + accepts JSON +
+ * surfaces structured errors. Uses undici `request` (not native `fetch`)
+ * because the test suite intercepts via `MockAgent` + `setGlobalDispatcher`
+ * — undici's `request` honours the global dispatcher reliably across the
+ * pinned undici version. Kept local (not shared with `pugi whoami`) so
+ * the routing surface is self-contained — extracting a common helper is
+ * α6.10b cleanup once we see two callers.
+ */
+async function fetchJson(url, apiKey, options = {}) {
+    const method = options.method ?? 'GET';
+    const headers = {
+        authorization: `Bearer ${apiKey}`,
+        accept: 'application/json',
+    };
+    let body;
+    if (options.body !== undefined) {
+        body = JSON.stringify(options.body);
+        headers['content-type'] = 'application/json';
+    }
+    const res = await request(url, { method, headers, body });
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+        const detail = await res.body.text().catch(() => '');
+        throw new Error(`pugi config routing: HTTP ${res.statusCode} on ${method} ${url}${detail ? ` -- ${detail.slice(0, 200)}` : ''}`);
+    }
+    // undici's `request` already returns `body` as a stream wrapped with
+    // helpers — `.json()` parses + closes for us.
+    return (await res.body.json());
+}
 //# sourceMappingURL=config.js.map

package/dist/runtime/commands/delegate.js

@@ -0,0 +1,289 @@
+/**
+ * Run the delegate command. Parses args, validates the brief, opens a
+ * fresh session, and POSTs the delegate brief.
+ *
+ * Sets `process.exitCode` instead of throwing so the caller (cli.ts
+ * handlers table) does not need a try/catch wrapper.
+ */
+export async function runDelegateCommand(args, ctx) {
+    // Extract the optional `--wait` flag from positional args. Accept it
+    // in any position so `pugi delegate --wait dev "..."` and
+    // `pugi delegate dev "..." --wait` both work; positional ordering of
+    // slug + brief is preserved by filtering the flag out before the
+    // slug/brief split (Claude P2 fix 2026-05-25).
+    const wait = args.some((a) => a === '--wait');
+    const positional = args.filter((a) => a !== '--wait');
+    const slug = positional[0];
+    const brief = positional.slice(1).join(' ').trim();
+    if (!slug || !brief) {
+        ctx.writeOutput({
+            ok: false,
+            error: 'Usage: pugi delegate [--wait] <persona-slug> "<one-sentence brief>"',
+        }, 'Usage: pugi delegate [--wait] <persona-slug> "<one-sentence brief>"');
+        process.exitCode = 2;
+        return;
+    }
+    // Brief size cap mirrors the server-side DTO (8000 chars). The local
+    // gate lets the operator know about the truncation before we waste a
+    // round-trip on a too-large brief.
+    if (brief.length > 8000) {
+        ctx.writeOutput({
+            ok: false,
+            error: `brief is ${brief.length} chars; max 8000`,
+        }, `pugi delegate: brief is ${brief.length} chars; max 8000.`);
+        process.exitCode = 2;
+        return;
+    }
+    const config = ctx.resolveConfig();
+    if (!config) {
+        ctx.writeOutput({
+            ok: false,
+            error: 'no Pugi credential configured; run `pugi login` first',
+        }, 'pugi delegate: no credential configured. Run `pugi login` first.');
+        process.exitCode = 1;
+        return;
+    }
+    const opened = await ctx.openSession(config, ctx.workspaceCwd);
+    if ('error' in opened) {
+        ctx.writeOutput({ ok: false, error: opened.error }, `pugi delegate: session open failed: ${opened.error}`);
+        process.exitCode = 1;
+        return;
+    }
+    const result = await ctx.submitDelegate(config, opened.sessionId, {
+        persona: slug,
+        brief,
+    });
+    switch (result.status) {
+        case 'ok': {
+            const ok = result.response;
+            if (!wait) {
+                ctx.writeOutput({
+                    ok: true,
+                    sessionId: opened.sessionId,
+                    dispatchId: ok.dispatchId,
+                    personaSlug: ok.personaSlug,
+                }, `dispatched ${ok.personaSlug} (dispatchId=${ok.dispatchId}); stream via GET /sessions/${opened.sessionId}/stream.`);
+                return;
+            }
+            // --wait: subscribe to SSE until the persona reaches a terminal
+            // event. The waiter contract is provider-shaped so tests can pass
+            // a fake without standing up fetch.
+            const waiter = ctx.waitForTerminal ?? waitForDelegateTerminal;
+            const outcome = await waiter(config, opened.sessionId, ok.personaSlug);
+            switch (outcome.kind) {
+                case 'completed':
+                    ctx.writeOutput({
+                        ok: true,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        personaSlug: outcome.personaSlug,
+                        status: 'completed',
+                    }, `completed ${outcome.personaSlug} (dispatchId=${ok.dispatchId}).`);
+                    return;
+                case 'blocked':
+                    ctx.writeOutput({
+                        ok: false,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        personaSlug: outcome.personaSlug,
+                        status: 'blocked',
+                        detail: outcome.detail,
+                    }, `blocked ${outcome.personaSlug}: ${outcome.detail}`);
+                    process.exitCode = 5;
+                    return;
+                case 'failed':
+                    ctx.writeOutput({
+                        ok: false,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        personaSlug: outcome.personaSlug,
+                        status: 'failed',
+                        error: outcome.error,
+                    }, `failed ${outcome.personaSlug}: ${outcome.error}`);
+                    process.exitCode = 5;
+                    return;
+                case 'stream_error':
+                    ctx.writeOutput({
+                        ok: false,
+                        sessionId: opened.sessionId,
+                        dispatchId: ok.dispatchId,
+                        error: outcome.error,
+                    }, `pugi delegate --wait: ${outcome.error}`);
+                    process.exitCode = 1;
+                    return;
+            }
+            return;
+        }
+        case 'unknown_persona':
+            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
+            process.exitCode = 3;
+            return;
+        case 'quota_exceeded':
+            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
+            process.exitCode = 4;
+            return;
+        case 'endpoint_missing':
+            ctx.writeOutput({
+                ok: false,
+                error: 'runtime does not expose POST /api/pugi/sessions/:id/delegate (upgrade admin-api to α7.5+)',
+                code: result.code,
+            }, 'pugi delegate: runtime does not expose the delegate endpoint. Upgrade admin-api to α7.5+.');
+            process.exitCode = 1;
+            return;
+        case 'unauthenticated':
+        case 'failed':
+            ctx.writeOutput({ ok: false, error: result.message, code: result.code }, `pugi delegate: ${result.message}`);
+            process.exitCode = 1;
+            return;
+    }
+}
+/* ------------------------------------------------------------------ */
+/* --wait waiter                                                      */
+/* ------------------------------------------------------------------ */
+/**
+ * Subscribe to the session SSE stream and resolve when the named
+ * persona reaches a terminal event (agent.completed / agent.blocked /
+ * agent.failed). Falls back to a `stream_error` outcome when the
+ * stream closes before any terminal event arrives or when the
+ * underlying fetch fails.
+ *
+ * The waiter is intentionally a single-call helper (not a long-lived
+ * subscriber) - the scripted `pugi delegate --wait` caller wants to
+ * exit on the first terminal event for THIS persona, not maintain a
+ * persistent connection.
+ *
+ * Why we parse the lifecycle in this file (not via the repl-render
+ * subscribe helper): repl-render carries Ink/React deps the
+ * non-interactive delegate path does not want to load. Duplicating the
+ * minimal SSE-line parser here keeps the command lean (this is the same
+ * shape `apps/admin-api/src/pugi/sessions.controller.ts` writes to the
+ * wire).
+ */
+export async function waitForDelegateTerminal(config, sessionId, targetPersonaSlug) {
+    const url = `${config.apiUrl.replace(/\/+$/, '')}/api/pugi/sessions/${encodeURIComponent(sessionId)}/stream`;
+    const controller = new AbortController();
+    // Hard-cap the waiter at 5 minutes so a stalled server cannot keep
+    // a scripted caller hanging forever; the dispatcher's per-turn budget
+    // is well under this.
+    const timeout = setTimeout(() => controller.abort(), 5 * 60 * 1000);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'text/event-stream',
+                Authorization: `Bearer ${config.apiKey}`,
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            return { kind: 'stream_error', error: `HTTP ${response.status}` };
+        }
+        if (!response.body) {
+            return { kind: 'stream_error', error: 'no response body' };
+        }
+        // Track the most-recent persona slug seen on agent.spawned so the
+        // terminal event (which carries only taskId) can be matched to the
+        // delegate target without parsing the random nonce suffix.
+        const taskToPersona = new Map();
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+        let currentData = '';
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done) {
+                return { kind: 'stream_error', error: 'stream ended without terminal event' };
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                const rawLine = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+                buffer = buffer.slice(newlineIndex + 1);
+                if (rawLine.length === 0) {
+                    if (currentData.length > 0) {
+                        const parsed = parseDelegateFrame(currentData);
+                        if (parsed) {
+                            if (parsed.type === 'agent.spawned') {
+                                taskToPersona.set(parsed.taskId, parsed.personaSlug);
+                            }
+                            else if (parsed.type === 'agent.completed' ||
+                                parsed.type === 'agent.blocked' ||
+                                parsed.type === 'agent.failed') {
+                                const slug = taskToPersona.get(parsed.taskId) ?? targetPersonaSlug;
+                                if (slug === targetPersonaSlug) {
+                                    controller.abort();
+                                    if (parsed.type === 'agent.completed') {
+                                        return {
+                                            kind: 'completed',
+                                            personaSlug: slug,
+                                            taskId: parsed.taskId,
+                                        };
+                                    }
+                                    if (parsed.type === 'agent.blocked') {
+                                        return {
+                                            kind: 'blocked',
+                                            personaSlug: slug,
+                                            taskId: parsed.taskId,
+                                            detail: parsed.detail,
+                                        };
+                                    }
+                                    return {
+                                        kind: 'failed',
+                                        personaSlug: slug,
+                                        taskId: parsed.taskId,
+                                        error: parsed.error,
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    currentData = '';
+                    continue;
+                }
+                if (rawLine.startsWith(':'))
+                    continue;
+                const colonIndex = rawLine.indexOf(':');
+                const field = colonIndex === -1 ? rawLine : rawLine.slice(0, colonIndex);
+                const value = colonIndex === -1 ? '' : rawLine.slice(colonIndex + 1).replace(/^ /, '');
+                if (field === 'data') {
+                    currentData = currentData.length === 0 ? value : `${currentData}\n${value}`;
+                }
+            }
+        }
+    }
+    catch (err) {
+        if (controller.signal.aborted) {
+            return { kind: 'stream_error', error: 'wait timed out' };
+        }
+        return { kind: 'stream_error', error: err.message };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function parseDelegateFrame(data) {
+    try {
+        const raw = JSON.parse(data);
+        const type = raw.type;
+        const taskId = typeof raw.taskId === 'string' ? raw.taskId : null;
+        if (!taskId)
+            return null;
+        if (type === 'agent.spawned' && typeof raw.personaSlug === 'string') {
+            return { type, taskId, personaSlug: raw.personaSlug };
+        }
+        if (type === 'agent.completed') {
+            return { type, taskId };
+        }
+        if (type === 'agent.blocked') {
+            return { type, taskId, detail: typeof raw.detail === 'string' ? raw.detail : '' };
+        }
+        if (type === 'agent.failed') {
+            return { type, taskId, error: typeof raw.error === 'string' ? raw.error : '' };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=delegate.js.map