@phnx-labs/agents-cli 1.20.52 → 1.20.53

package/dist/lib/answer-router.js

@@ -0,0 +1,149 @@
+import { injectTargetFromReplyRail } from './session/inject.js';
+/**
+ * Match free-text answer against question options.
+ * Exact (case-insensitive) > startsWith > includes. Returns 0-based index or -1.
+ */
+export function matchOptionIndex(answer, options) {
+    if (!options?.length)
+        return -1;
+    const needle = answer.trim().toLowerCase();
+    if (!needle)
+        return -1;
+    const labels = options.map((o) => (o.label ?? '').trim());
+    const exact = labels.findIndex((l) => l.toLowerCase() === needle);
+    if (exact >= 0)
+        return exact;
+    const starts = labels.findIndex((l) => l.toLowerCase().startsWith(needle));
+    if (starts >= 0)
+        return starts;
+    const includes = labels.findIndex((l) => l.toLowerCase().includes(needle));
+    return includes;
+}
+/**
+ * Build the keystroke payload that closes an AskUserQuestion TUI.
+ * Numbered options are selected by digit (1-based) + Enter. Free text with an
+ * "Other" option selects Other then types; without Other, types the answer.
+ */
+export function keystrokesForAnswer(answer, options) {
+    const idx = matchOptionIndex(answer, options);
+    if (idx >= 0) {
+        // AskUserQuestion / plan select-lists are 1-indexed digits.
+        return { payload: `${idx + 1}`, matched: 'option' };
+    }
+    if (options?.length) {
+        const otherIdx = options.findIndex((o) => /^other$/i.test((o.label ?? '').trim()));
+        if (otherIdx >= 0) {
+            // Select Other, then type the free text on the next field.
+            return { payload: `${otherIdx + 1}\n${answer}`, matched: 'other' };
+        }
+    }
+    return { payload: answer, matched: 'free-text' };
+}
+/** True when the session is waiting on user input (parked on a question/plan). */
+export function isParkedOnInput(session) {
+    if (!session)
+        return false;
+    if (session.status === 'input_required')
+        return true;
+    if (session.activity === 'waiting_input')
+        return true;
+    if (session.awaitingReason === 'question' || session.awaitingReason === 'plan_review' || session.awaitingReason === 'permission') {
+        return true;
+    }
+    return false;
+}
+/** True when an open feed block still needs an answer. */
+export function isOpenQuestionBlock(block) {
+    if (!block)
+        return false;
+    if (block.answer || block.parkedAt || block.continuedAt || block.defaultedAt)
+        return false;
+    return (block.questions?.length ?? 0) > 0;
+}
+function injectTargetForSession(session) {
+    if (session.provenance?.reply) {
+        const fromRail = injectTargetFromReplyRail(session.provenance.reply);
+        if (fromRail)
+            return fromRail;
+    }
+    // Only the agents-pty sidecar is addressable by session id. Generic headless
+    // runs have no PTY server entry — those go through resume, not inject.
+    if (session.sessionId && session.host === 'pty') {
+        return { backend: 'pty', id: session.sessionId };
+    }
+    return null;
+}
+/**
+ * Pick the delivery mechanism for one answer.
+ *
+ * Precedence:
+ *   1. Parked on open question + injectable rail (tmux/iterm/pty) → keystroke
+ *   2. Parked on open question + headless (no rail) → resume with answer
+ *   3. Parked on open question + no rail + interactive → refuse (don't mailbox-drop)
+ *   4. Otherwise → mailbox (running agent between tool calls)
+ */
+export function resolveAnswerRoute(input) {
+    const { answer, block, session } = input;
+    const openQ = isOpenQuestionBlock(block);
+    const parked = isParkedOnInput(session);
+    // Options from the first question on the block (or the session's structured question).
+    const options = block?.questions?.[0]?.options ??
+        session?.question?.options?.map((o) => ({ label: o.label }));
+    if (openQ && parked && session) {
+        const inject = injectTargetForSession(session);
+        const { payload, matched } = keystrokesForAnswer(answer, options);
+        if (inject) {
+            const kind = inject.backend === 'tmux' ? 'tmux'
+                : inject.backend === 'iterm' ? 'iterm'
+                    : inject.backend === 'pty' ? 'pty'
+                        : 'pty';
+            return {
+                kind,
+                reason: `Parked on open question — drive ${inject.backend} selection (${matched}).`,
+                payload,
+                inject,
+            };
+        }
+        // Headless / no rail: re-enter via resume.
+        if (session.context === 'headless' || session.context === 'teams' || !session.tty) {
+            const sid = session.sessionId ?? input.mailboxId;
+            if (!sid) {
+                return {
+                    kind: 'refuse',
+                    reason: 'Parked headless agent has no session id to resume.',
+                };
+            }
+            return {
+                kind: 'resume',
+                reason: 'Parked headless agent — resume with the answer as the next user turn.',
+                payload: answer,
+                resume: { sessionId: sid, agent: session.kind },
+            };
+        }
+        return {
+            kind: 'refuse',
+            reason: 'Agent is parked on a question but has no addressable terminal (no tmux/iterm/pty rail). ' +
+                'Open its terminal and answer there, or run `agents sessions focus <id>` first.',
+        };
+    }
+    // Open block but agent is still looping between tool calls — mailbox is correct.
+    // No block — free-form mid-flight steer — mailbox.
+    return {
+        kind: 'mailbox',
+        reason: openQ
+            ? 'Open block on a running agent — deliver via mailbox at next tool call.'
+            : 'No open question — deliver via mailbox at next tool call.',
+        payload: answer,
+    };
+}
+/** Build argv for a headless resume that continues with the answer text. */
+export function resumeArgv(route) {
+    if (route.kind !== 'resume' || !route.resume) {
+        throw new Error('resumeArgv requires a resume route');
+    }
+    const { agent, sessionId } = route.resume;
+    const text = route.payload ?? '';
+    // `agents run <agent> --resume <id> -- <answer>` — the trailing prompt is the
+    // next user turn after native resume (claude/codex) or /continue replay.
+    return ['run', agent, '--resume', sessionId, '--', text];
+}

package/dist/lib/ask-classifier.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Ask classifier + stall suppression (RUSH-1477).
+ *
+ * ~39% of AskUserQuestion calls are workflow-stalls ("should I…?", "what's next?",
+ * "merge now?"). The feed's first job is to make those disappear so real Decisions
+ * and Approvals stay visible.
+ *
+ * Pipeline:
+ *   1. Classify every block into Decision / Approval / Clarification / Stall / Fyi
+ *   2. Suppress stalls (and pure FYIs) with an auto-answer so they never render
+ *   3. Surface Decision + Approval (+ Clarification when it needs a real fact)
+ *
+ * Rules-based on stable high-volume shapes. Pure classify/match; suppression has
+ * side effects via the feed store when applied.
+ */
+import type { OpenBlock } from './feed.js';
+/** Taxonomy for a published ask. Exactly one class per block. */
+export type AskClass = 'decision' | 'approval' | 'clarification' | 'stall' | 'fyi';
+export interface Classification {
+    class: AskClass;
+    /** Why this class was chosen (rule name). */
+    rule: string;
+    /** True when the feed should hide this block and auto-answer it. */
+    suppress: boolean;
+    /** Auto-answer text when suppress is true. */
+    autoAnswer?: string;
+}
+/** Scan text used for classification. */
+export declare function askScanText(block: Pick<OpenBlock, 'questions'>): string;
+/**
+ * Classify one ask from free text (+ optional explicit blockClass from the agent).
+ * Explicit blockClass from the agent is honored as a floor: 'decision' never becomes
+ * a suppressible stall (false-suppress rate ~0 for real Decisions).
+ */
+export declare function classifyAsk(text: string, opts?: {
+    header?: string;
+    blockClass?: OpenBlock['blockClass'];
+}): Classification;
+/** Classify a full open block (all questions concatenated). */
+export declare function classifyBlock(block: OpenBlock): Classification;
+export interface SuppressResult {
+    blockId: string;
+    class: AskClass;
+    rule: string;
+    autoAnswer: string;
+    /** True when the block was removed from the visible feed. */
+    suppressed: boolean;
+}
+/**
+ * Auto-answer + remove a suppressible block so it never renders as a card.
+ * Logs the stall as answered by policy:stall-suppression.
+ */
+export declare function suppressStallBlock(block: OpenBlock, root?: string): SuppressResult;
+export interface FeedFilterResult {
+    /** Blocks that should render as cards. */
+    surfaced: OpenBlock[];
+    /** Suppression audit rows (stalls auto-resolved). */
+    suppressed: SuppressResult[];
+    /** Per-class counts over the input set (before suppression). */
+    counts: Record<AskClass, number>;
+}
+/**
+ * Classify every block; optionally apply stall suppression (mutate store).
+ * When `apply` is false, only classifies (dry run for --json audit).
+ */
+export declare function filterBlocksForFeed(blocks: OpenBlock[], opts?: {
+    apply?: boolean;
+    root?: string;
+}): FeedFilterResult;
+/** Human digest: "31 stalls auto-resolved by policy". */
+export declare function suppressionDigest(result: FeedFilterResult): string;

package/dist/lib/ask-classifier.js

@@ -0,0 +1,197 @@
+import { recordAnswer, recordMessageReceipt, removeBlock } from './feed.js';
+import { enqueue, mailboxDir } from './mailbox.js';
+/** Scan text used for classification. */
+export function askScanText(block) {
+    return block.questions
+        .map((q) => [q.header, q.text].filter(Boolean).join(' '))
+        .join('\n')
+        .toLowerCase();
+}
+const RULES = [
+    // FYI / done — no action needed
+    {
+        name: 'fyi-done',
+        class: 'fyi',
+        suppress: true,
+        autoAnswer: 'acknowledged',
+        test: (t) => /\b(fyi|for your information|just letting you know|heads.?up|no action needed|already done|completed successfully)\b/.test(t) ||
+            /^(done|shipped|merged|complete)[.!]?$/.test(t.trim()),
+    },
+    // Stall: "should I / want me to / shall I continue"
+    {
+        name: 'stall-should-i',
+        class: 'stall',
+        suppress: true,
+        autoAnswer: 'Yes, continue.',
+        test: (t) => /\b(should i|shall i|want me to|would you like me to|do you want me to|can i go ahead|ok to proceed|okay to continue)\b/.test(t),
+    },
+    // Stall: "what's next / continue?"
+    {
+        name: 'stall-whats-next',
+        class: 'stall',
+        suppress: true,
+        autoAnswer: 'Continue with the next step.',
+        test: (t) => /\b(what('?s| is)? next|what now|continue\??|keep going\??|ready for the next|next step\??)\b/.test(t) ||
+            /^continue\??$/.test(t.trim()),
+    },
+    // Stall: verify-then-proceed / looks good?
+    {
+        name: 'stall-verify-proceed',
+        class: 'stall',
+        suppress: true,
+        autoAnswer: 'Looks good — proceed.',
+        test: (t) => /\b(looks good\??|does this look (ok|right|good)|sound good\??|ready to (go|ship|land)\??|any objections\??)\b/.test(t),
+    },
+    // Approval: merge/release/ship/commit yes-no (surfaces; policy can default later)
+    {
+        name: 'approval-merge-release',
+        class: 'approval',
+        suppress: false,
+        test: (t) => /\b(merge (now|this|the pr|it)\??|release\??|ship (it|now)\??|publish\??|cut (a )?release|tag (and )?release|commit (this|these changes)\??)\b/.test(t) ||
+            /\b(approve|deny|allow|reject)\b.*\b(merge|release|deploy|pr)\b/.test(t),
+    },
+    // Clarification: which X / which repo / pick one fact
+    {
+        name: 'clarification-which',
+        class: 'clarification',
+        suppress: false,
+        test: (t) => /\b(which (repo|branch|host|file|path|environment|env|project|package|version|account|device|machine)|what is the (path|url|id|name) of)\b/.test(t) ||
+            /\b(missing (the )?(path|url|id|name|repo)|need (the )?(path|url|id|repo) for)\b/.test(t),
+    },
+    // Decision: scope / approach / tradeoff (never auto-suppress)
+    {
+        name: 'decision-scope-approach',
+        class: 'decision',
+        suppress: false,
+        test: (t) => /\b(scope|approach|architecture|design|trade-?off|which approach|how should we|prefer A or B|option a or b)\b/.test(t) ||
+            /\b(break(ing)? change|public api|migrate everyone|rewrite)\b/.test(t),
+    },
+];
+/**
+ * Classify one ask from free text (+ optional explicit blockClass from the agent).
+ * Explicit blockClass from the agent is honored as a floor: 'decision' never becomes
+ * a suppressible stall (false-suppress rate ~0 for real Decisions).
+ */
+export function classifyAsk(text, opts) {
+    const scan = [opts?.header, text].filter(Boolean).join(' ').toLowerCase();
+    for (const rule of RULES) {
+        if (!rule.test(scan))
+            continue;
+        // Safety: agent-tagged decisions never suppress.
+        if (opts?.blockClass === 'decision' && rule.suppress) {
+            return { class: 'decision', rule: 'agent-blockClass-decision', suppress: false };
+        }
+        return {
+            class: rule.class,
+            rule: rule.name,
+            suppress: rule.suppress,
+            autoAnswer: rule.autoAnswer,
+        };
+    }
+    // Explicit agent tag with no text rule.
+    if (opts?.blockClass === 'decision') {
+        return { class: 'decision', rule: 'agent-blockClass-decision', suppress: false };
+    }
+    if (opts?.blockClass === 'approval') {
+        return { class: 'approval', rule: 'agent-blockClass-approval', suppress: false };
+    }
+    // Default: surface as decision so we never silent-drop unknowns.
+    return { class: 'decision', rule: 'default-decision', suppress: false };
+}
+/** Classify a full open block (all questions concatenated). */
+export function classifyBlock(block) {
+    const text = block.questions.map((q) => q.text).join(' ');
+    const header = block.questions.map((q) => q.header).filter(Boolean).join(' ');
+    return classifyAsk(text, { header, blockClass: block.blockClass });
+}
+/**
+ * Auto-answer + remove a suppressible block so it never renders as a card.
+ * Logs the stall as answered by policy:stall-suppression.
+ */
+export function suppressStallBlock(block, root) {
+    const c = classifyBlock(block);
+    if (!c.suppress || !c.autoAnswer) {
+        return { blockId: block.blockId, class: c.class, rule: c.rule, autoAnswer: '', suppressed: false };
+    }
+    const claim = recordAnswer(block.blockId, {
+        answeredFrom: 'policy',
+        answeredBy: 'stall-suppression',
+        operatorId: 'policy',
+        verified: true,
+    }, root);
+    if (!claim.ok) {
+        return { blockId: block.blockId, class: c.class, rule: c.rule, autoAnswer: c.autoAnswer, suppressed: false };
+    }
+    try {
+        // Mailbox lives under the global mailbox root (not the feed dir).
+        const msgId = enqueue(mailboxDir(block.mailboxId), {
+            to: block.mailboxId,
+            text: c.autoAnswer,
+            from: 'stall-suppression',
+            blockId: block.blockId,
+        });
+        recordMessageReceipt(block.blockId, { msgId, status: 'queued', at: new Date().toISOString(), from: 'stall-suppression' }, root);
+    }
+    catch {
+        // Mailbox write can fail if the box id is invalid; still drop the card.
+    }
+    removeBlock(block.blockId, root);
+    return {
+        blockId: block.blockId,
+        class: c.class,
+        rule: c.rule,
+        autoAnswer: c.autoAnswer,
+        suppressed: true,
+    };
+}
+/**
+ * Classify every block; optionally apply stall suppression (mutate store).
+ * When `apply` is false, only classifies (dry run for --json audit).
+ */
+export function filterBlocksForFeed(blocks, opts) {
+    const counts = {
+        decision: 0,
+        approval: 0,
+        clarification: 0,
+        stall: 0,
+        fyi: 0,
+    };
+    const surfaced = [];
+    const suppressed = [];
+    const apply = opts?.apply === true;
+    for (const block of blocks) {
+        const c = classifyBlock(block);
+        counts[c.class] += 1;
+        if (c.suppress) {
+            if (apply) {
+                const r = suppressStallBlock(block, opts?.root);
+                suppressed.push(r);
+                if (!r.suppressed)
+                    surfaced.push(block);
+            }
+            else {
+                suppressed.push({
+                    blockId: block.blockId,
+                    class: c.class,
+                    rule: c.rule,
+                    autoAnswer: c.autoAnswer ?? '',
+                    suppressed: false,
+                });
+            }
+        }
+        else {
+            surfaced.push(block);
+        }
+    }
+    return { surfaced, suppressed, counts };
+}
+/** Human digest: "31 stalls auto-resolved by policy". */
+export function suppressionDigest(result) {
+    const n = result.suppressed.filter((s) => s.suppressed || s.class === 'stall' || s.class === 'fyi').length;
+    if (n === 0)
+        return '';
+    const applied = result.suppressed.filter((s) => s.suppressed).length;
+    if (applied > 0)
+        return `${applied} stall${applied === 1 ? '' : 's'} auto-resolved by policy`;
+    return `${n} stall${n === 1 ? '' : 's'} eligible for suppression`;
+}

package/dist/lib/cloud/antigravity.d.ts

@@ -31,8 +31,6 @@ interface InteractionResponse {
         message?: string;
     } | string;
 }
-/** Map an Interactions API status string to the canonical CloudTaskStatus. */
-export declare function mapStatus(s: string | undefined): CloudTaskStatus;
 /** Build the Interactions API request body for a fresh dispatch. */
 export declare function buildInteractionBody(prompt: string, model: string): Record<string, unknown>;
 /** Parse an Interactions API response into a CloudTask (minus prompt/timestamps). */

package/dist/lib/cloud/antigravity.js

@@ -19,26 +19,11 @@
  * `cloud.providers.antigravity.secretsBundle` (never from agents.yaml), falling
  * back to GEMINI_API_KEY / GOOGLE_API_KEY in the environment.
  */
-import { resolveDispatchRepos } from './types.js';
+import { resolveDispatchRepos, normalizeProviderStatus } from './types.js';
 import { readAndResolveBundleEnv } from '../secrets/bundles.js';
 const INTERACTIONS_URL = 'https://generativelanguage.googleapis.com/v1beta/interactions';
 const DEFAULT_MODEL = 'antigravity-preview-05-2026';
 const KEY_NAMES = ['GEMINI_API_KEY', 'GOOGLE_API_KEY'];
-/** Map an Interactions API status string to the canonical CloudTaskStatus. */
-export function mapStatus(s) {
-    const lower = (s ?? '').toLowerCase();
-    if (lower.includes('queue') || lower.includes('pending'))
-        return 'queued';
-    if (lower.includes('run') || lower.includes('progress'))
-        return 'running';
-    if (lower.includes('complete') || lower.includes('success'))
-        return 'completed';
-    if (lower.includes('fail') || lower.includes('error'))
-        return 'failed';
-    if (lower.includes('cancel'))
-        return 'cancelled';
-    return 'completed';
-}
 /** Build the Interactions API request body for a fresh dispatch. */
 export function buildInteractionBody(prompt, model) {
     return {
@@ -52,7 +37,7 @@ export function parseInteraction(resp) {
     const id = resp.id ?? resp.interaction_id ?? `antigravity-${Date.now()}`;
     return {
         id,
-        status: mapStatus(resp.status),
+        status: normalizeProviderStatus('antigravity', resp.status),
         summary: resp.output_text,
         environmentId: resp.environment_id,
     };

package/dist/lib/cloud/codex.js

@@ -8,24 +8,9 @@
 import { spawn, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
-import { resolveDispatchRepos, MissingTargetError } from './types.js';
+import { resolveDispatchRepos, normalizeProviderStatus, MissingTargetError } from './types.js';
 import { getShimsDir } from '../state.js';
 const SHIMS_DIR = getShimsDir();
-/** Map a Codex Cloud status string to the canonical CloudTaskStatus enum. */
-function mapStatus(s) {
-    const lower = s.toLowerCase();
-    if (lower.includes('queued') || lower.includes('pending'))
-        return 'queued';
-    if (lower.includes('running') || lower.includes('in_progress'))
-        return 'running';
-    if (lower.includes('completed') || lower.includes('succeeded') || lower.includes('success'))
-        return 'completed';
-    if (lower.includes('failed') || lower.includes('error'))
-        return 'failed';
-    if (lower.includes('cancelled') || lower.includes('canceled'))
-        return 'cancelled';
-    return 'running';
-}
 /** Locate the codex binary, checking agents-cli shims first then PATH. */
 function findCodexBinary() {
     // Check agents-cli shims first
@@ -77,7 +62,7 @@ function parseTaskFromText(text) {
         }
         return {
             id: result.id || result.task_id,
-            status: result.status ? mapStatus(result.status) : undefined,
+            status: result.status ? normalizeProviderStatus('codex', result.status) : undefined,
             summary: result.summary || result.output,
         };
     }
@@ -186,7 +171,7 @@ export class CodexCloudProvider {
             const tasks = (data.tasks ?? data ?? []).map((t) => ({
                 id: (t.id || t.task_id),
                 provider: 'codex',
-                status: mapStatus(t.status ?? ''),
+                status: normalizeProviderStatus('codex', t.status ?? ''),
                 agent: 'codex',
                 prompt: (t.prompt || t.query || ''),
                 branch: t.branch || undefined,

package/dist/lib/cloud/rush.js

@@ -10,7 +10,7 @@ import * as os from 'os';
 import * as crypto from 'crypto';
 import * as yaml from 'yaml';
 import { getCloudDir } from '../state.js';
-import { resolveDispatchRepos, MAX_IMAGES_PER_DISPATCH } from './types.js';
+import { resolveDispatchRepos, normalizeProviderStatus, MAX_IMAGES_PER_DISPATCH } from './types.js';
 import { parseSSE } from './stream.js';
 import { listInstalledVersions, getVersionHomePath } from '../versions.js';
 import { getAccountInfo } from '../agents.js';
@@ -56,18 +56,6 @@ function recordRushUploadConsent(grantedBy, accountFingerprint) {
         // boundary. Worst case, the user is asked to consent again next dispatch.
     }
 }
-/** Map a Factory Floor status string to the canonical CloudTaskStatus enum. */
-function mapStatus(s) {
-    switch (s) {
-        case 'allocating': return 'allocating';
-        case 'running': return 'running';
-        case 'needs_review': return 'input_required';
-        case 'completed': return 'completed';
-        case 'failed': return 'failed';
-        case 'cancelled': return 'cancelled';
-        default: return 'running';
-    }
-}
 /** Read the Rush session access token from ~/.rush/user.yaml. */
 function readToken() {
     if (!fs.existsSync(USER_YAML)) {
@@ -452,7 +440,7 @@ export class RushCloudProvider {
         return {
             id: taskId,
             provider: 'rush',
-            status: mapStatus(data.status),
+            status: normalizeProviderStatus('rush', data.status),
             agent: data.agent || undefined,
             prompt: data.prompt || '',
             repo: data.repo_owner && data.repo_name ? `${data.repo_owner}/${data.repo_name}` : undefined,
@@ -477,7 +465,7 @@ export class RushCloudProvider {
         return (data.executions ?? []).map((e) => ({
             id: e.execution_id,
             provider: 'rush',
-            status: mapStatus(e.status),
+            status: normalizeProviderStatus('rush', e.status),
             agent: e.agent || undefined,
             prompt: e.prompt || '',
             repo: e.repo_owner && e.repo_name ? `${e.repo_owner}/${e.repo_name}` : undefined,

package/dist/lib/cloud/stream.js

@@ -179,6 +179,8 @@ function statusLabel(status) {
             return chalk.blue(`[${status}]`);
         case 'running':
             return chalk.yellow(`[${status}]`);
+        case 'idle':
+            return chalk.dim('[idle]');
         case 'completed':
             return chalk.green('[completed]');
         case 'needs_review':

package/dist/lib/cloud/types.d.ts

@@ -27,6 +27,27 @@ export type CloudProviderId = 'rush' | 'codex' | 'factory' | 'antigravity';
  * failed | cancelled` states, which cannot transition back to `running`.
  */
 export type CloudTaskStatus = 'queued' | 'allocating' | 'running' | 'idle' | 'input_required' | 'completed' | 'failed' | 'cancelled';
+/** Cloud backends whose wire status is normalized by `normalizeProviderStatus`. */
+export type StatusNormalizingProvider = 'rush' | 'codex' | 'antigravity';
+/**
+ * Normalize a provider's raw wire status into the canonical `CloudTaskStatus`.
+ *
+ * Each cloud backend speaks its own status vocabulary and had its own copy of
+ * this mapping, which had drifted. This dispatches per provider while keeping
+ * provider-specific defaults explicit:
+ *   - `rush`        — switch over the Factory Floor's known strings; includes
+ *                     `allocating` and stopped/resumable `idle` states, has no
+ *                     `queued`, default `running`.
+ *   - `codex`       — substring match on the lowercased CLI status; default
+ *                     `running`.
+ *   - `antigravity` — substring match on the (possibly `undefined`) Interactions
+ *                     API status; default `completed` (its synchronous response
+ *                     is terminal), and `undefined`-safe.
+ *
+ * Factory's `mapResultStatus` is structurally different (it maps a droid *exit*
+ * result, not a lifecycle string) and deliberately stays in `factory.ts`.
+ */
+export declare function normalizeProviderStatus(provider: StatusNormalizingProvider, wireStatus: string | undefined): CloudTaskStatus;
 /** Snapshot of a dispatched task, stored locally and refreshed from the provider. */
 export interface CloudTask {
     id: string;