@phnx-labs/agents-cli 1.22.119 → 1.22.121

package/dist/lib/session/shell-programs.js

@@ -1,380 +0,0 @@
-import path from 'path';
-import { parse, } from 'unbash';
-/**
- * Harness tool NAMES that run a shell command — Claude's `Bash`, Codex's
- * `exec_command`/`exec` (`exec` is newer gpt-5.6-sol), Droid's `Execute`, plus the
- * generic `shell`/`run_shell_command`/`run_command`/`execute`. This is the single
- * source of truth for "does this tool row carry a shell command?", consumed by the
- * trajectory model (program resolution + command-arg extraction), the directory-touched
- * scan in `state.ts`, the tool-call indexer, and stream rendering — replacing five
- * hand-synced copies that had already drifted apart.
- *
- * Distinct from {@link SHELL_WRAPPERS}, which is interpreter binaries (`bash`, `sh`…)
- * found INSIDE a command string, not the harness's tool name. Match through
- * {@link isShellExecTool} so casing is normalized in one place — harnesses disagree on
- * case (`Bash` vs `bash`, `Execute` vs `exec_command`).
- */
-export const SHELL_EXEC_TOOLS = new Set([
-    'bash', 'exec', 'execute', 'exec_command', 'run_command', 'run_shell_command', 'shell',
-]);
-/** Case-insensitive membership test for {@link SHELL_EXEC_TOOLS}. */
-export function isShellExecTool(tool) {
-    return tool !== undefined && SHELL_EXEC_TOOLS.has(tool.toLowerCase());
-}
-const SHELL_WRAPPERS = new Set(['bash', 'sh', 'zsh', 'dash', 'ksh']);
-const PROGRAM_WRAPPERS = new Set(['command', 'builtin', 'env', 'nohup', 'sudo']);
-const MAX_NESTED_DEPTH = 3;
-const SUDO_OPTIONS_WITH_VALUE = new Set([
-    '-C', '--close-from', '-D', '--chdir', '-g', '--group', '-h', '--device',
-    '-p', '--prompt', '-R', '--chroot', '-r', '--role', '-t', '--type',
-    '-T', '--command-timeout', '-u', '--user',
-]);
-function normalizeProgram(value) {
-    const trimmed = value.trim();
-    if (!trimmed || trimmed.includes('\0'))
-        return undefined;
-    const normalized = trimmed.replace(/\\/g, '/');
-    const base = path.posix.basename(normalized);
-    return base || undefined;
-}
-function staticParts(parts) {
-    if (!parts)
-        return true;
-    return parts.every((part) => {
-        switch (part.type) {
-            case 'Literal':
-            case 'SingleQuoted':
-            case 'AnsiCQuoted':
-                return true;
-            case 'DoubleQuoted':
-            case 'LocaleString':
-                return staticParts(part.parts);
-            default:
-                return false;
-        }
-    });
-}
-/** Return a word only when Bash expansion cannot change its value. */
-export function staticShellWord(word) {
-    if (!word || !staticParts(word.parts))
-        return undefined;
-    return word.value || undefined;
-}
-function walkWord(word, visitScript) {
-    if (!word)
-        return;
-    const walkPart = (part) => {
-        switch (part.type) {
-            case 'DoubleQuoted':
-            case 'LocaleString':
-                part.parts.forEach(walkPart);
-                break;
-            case 'CommandExpansion':
-            case 'ProcessSubstitution':
-                if (part.script)
-                    visitScript(part.script);
-                break;
-            case 'ArithmeticExpansion':
-                if (part.expression)
-                    walkArithmetic(part.expression, visitScript);
-                break;
-            case 'ParameterExpansion':
-                part.indexParts?.forEach(walkPart);
-                walkWord(part.operand, visitScript);
-                if (part.slice) {
-                    walkWord(part.slice.offset, visitScript);
-                    walkWord(part.slice.length, visitScript);
-                }
-                if (part.replace) {
-                    walkWord(part.replace.pattern, visitScript);
-                    walkWord(part.replace.replacement, visitScript);
-                }
-                break;
-            case 'ExtendedGlob':
-            case 'BraceExpansion':
-                part.parts?.forEach(walkPart);
-                break;
-            default:
-                break;
-        }
-    };
-    // `parts` is a lazy getter in unbash. Access it explicitly; Object.keys(word)
-    // does not enumerate expansions.
-    word.parts?.forEach(walkPart);
-}
-function walkArithmetic(expr, visitScript) {
-    switch (expr.type) {
-        case 'ArithmeticBinary':
-            walkArithmetic(expr.left, visitScript);
-            walkArithmetic(expr.right, visitScript);
-            break;
-        case 'ArithmeticUnary':
-            walkArithmetic(expr.operand, visitScript);
-            break;
-        case 'ArithmeticTernary':
-            walkArithmetic(expr.test, visitScript);
-            walkArithmetic(expr.consequent, visitScript);
-            walkArithmetic(expr.alternate, visitScript);
-            break;
-        case 'ArithmeticGroup':
-            walkArithmetic(expr.expression, visitScript);
-            break;
-        case 'ArithmeticWord':
-            expr.parts?.forEach((part) => walkWordPart(part, visitScript));
-            break;
-        case 'ArithmeticCommandExpansion':
-            if (expr.script)
-                visitScript(expr.script);
-            break;
-    }
-}
-function walkWordPart(part, visitScript) {
-    const synthetic = { text: part.text, value: '', pos: 0, end: 0, parts: [part] };
-    walkWord(synthetic, visitScript);
-}
-function walkTest(expr, visitScript) {
-    switch (expr.type) {
-        case 'TestUnary':
-            walkWord(expr.operand, visitScript);
-            break;
-        case 'TestBinary':
-            walkWord(expr.left, visitScript);
-            walkWord(expr.right, visitScript);
-            break;
-        case 'TestLogical':
-            walkTest(expr.left, visitScript);
-            walkTest(expr.right, visitScript);
-            break;
-        case 'TestNot':
-            walkTest(expr.operand, visitScript);
-            break;
-        case 'TestGroup':
-            walkTest(expr.expression, visitScript);
-            break;
-    }
-}
-function nestedPayload(command) {
-    const program = normalizeProgram(staticShellWord(command.name) ?? '');
-    const suffix = command.suffix.map(staticShellWord);
-    if (!program || suffix.some((part) => part === undefined))
-        return undefined;
-    const words = suffix;
-    if (SHELL_WRAPPERS.has(program)) {
-        const flagIndex = words.findIndex((word) => /^-[a-zA-Z]*c[a-zA-Z]*$/.test(word));
-        return flagIndex >= 0 ? words[flagIndex + 1] : undefined;
-    }
-    if (program === 'ssh') {
-        let i = 0;
-        while (i < words.length && words[i].startsWith('-')) {
-            const option = words[i++];
-            if (/^-(?:b|c|D|E|F|I|i|J|L|l|m|O|o|p|Q|R|S|W|w)$/.test(option))
-                i++;
-        }
-        i++; // host
-        return i < words.length ? words.slice(i).join(' ') : undefined;
-    }
-    if ((program === 'agents' || program === 'ag') && words[0] === 'ssh') {
-        return words.length > 2 ? words.slice(2).join(' ') : undefined;
-    }
-    return undefined;
-}
-function wrapperDelegate(words, wrapper) {
-    let index = 0;
-    if (wrapper === 'env') {
-        while (index < words.length) {
-            const word = words[index];
-            if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) {
-                index++;
-                continue;
-            }
-            if (word === '-u' || word === '--unset' || word === '-C' || word === '--chdir') {
-                index += 2;
-                continue;
-            }
-            if (word === '--') {
-                index++;
-                break;
-            }
-            if (word.startsWith('-')) {
-                index++;
-                continue;
-            }
-            break;
-        }
-    }
-    else if (wrapper === 'sudo') {
-        while (index < words.length) {
-            const word = words[index];
-            if (word === '--') {
-                index++;
-                break;
-            }
-            const option = word.includes('=') ? word.slice(0, word.indexOf('=')) : word;
-            if (!word.startsWith('-'))
-                break;
-            index++;
-            if (!word.includes('=') && SUDO_OPTIONS_WITH_VALUE.has(option))
-                index++;
-        }
-        while (index < words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[index]))
-            index++;
-    }
-    else {
-        while (index < words.length && words[index].startsWith('-')) {
-            if (words[index++] === '--')
-                break;
-        }
-    }
-    return index < words.length ? words.slice(index) : undefined;
-}
-/** Parse Bash without executing it and return every statically identifiable program. */
-export function extractShellPrograms(source, depth = 0) {
-    const programs = [];
-    const occurrences = [];
-    const diagnostics = [];
-    const seen = new Set();
-    const add = (value, role) => {
-        const program = value ? normalizeProgram(value) : undefined;
-        if (!program)
-            return undefined;
-        occurrences.push({ program, role });
-        if (!seen.has(program)) {
-            seen.add(program);
-            programs.push(program);
-        }
-        return program;
-    };
-    const addWrapperDelegates = (wrapper, words) => {
-        let remaining = wrapperDelegate(words, wrapper);
-        while (remaining) {
-            const program = normalizeProgram(remaining[0]);
-            if (!program)
-                return;
-            const isWrapper = PROGRAM_WRAPPERS.has(program);
-            add(program, isWrapper ? 'wrapper' : 'effective');
-            if (!isWrapper)
-                return;
-            remaining = wrapperDelegate(remaining.slice(1), program);
-        }
-    };
-    const visitScript = (script) => {
-        for (const error of script.errors ?? [])
-            diagnostics.push(`${error.pos}: ${error.message}`);
-        script.commands.forEach((statement) => visitNode(statement));
-    };
-    const visitNode = (node) => {
-        switch (node.type) {
-            case 'Statement':
-                visitNode(node.command);
-                node.redirects.forEach((redirect) => {
-                    walkWord(redirect.target, visitScript);
-                    if (!redirect.heredocQuoted)
-                        walkWord(redirect.body, visitScript);
-                });
-                break;
-            case 'Command': {
-                const program = staticShellWord(node.name);
-                const normalized = normalizeProgram(program ?? '');
-                const payload = nestedPayload(node);
-                add(program, normalized && (PROGRAM_WRAPPERS.has(normalized) || payload) ? 'wrapper' : 'effective');
-                node.prefix.forEach((prefix) => {
-                    walkWord(prefix.value, visitScript);
-                    prefix.indexParts?.forEach((part) => walkWordPart(part, visitScript));
-                    prefix.array?.forEach((word) => walkWord(word, visitScript));
-                });
-                walkWord(node.name, visitScript);
-                node.suffix.forEach((word) => walkWord(word, visitScript));
-                node.redirects.forEach((redirect) => {
-                    walkWord(redirect.target, visitScript);
-                    if (!redirect.heredocQuoted)
-                        walkWord(redirect.body, visitScript);
-                });
-                if (normalized && PROGRAM_WRAPPERS.has(normalized)) {
-                    const words = node.suffix.map(staticShellWord);
-                    if (words.every((word) => word !== undefined)) {
-                        addWrapperDelegates(normalized, words);
-                    }
-                }
-                if (payload && depth < MAX_NESTED_DEPTH) {
-                    const nested = extractShellPrograms(payload, depth + 1);
-                    for (const occurrence of nested.occurrences)
-                        add(occurrence.program, occurrence.role);
-                    diagnostics.push(...nested.diagnostics);
-                }
-                break;
-            }
-            case 'Pipeline':
-            case 'AndOr':
-                node.commands.forEach(visitNode);
-                break;
-            case 'If':
-                visitNode(node.clause);
-                visitNode(node.then);
-                if (node.else)
-                    visitNode(node.else);
-                break;
-            case 'For':
-            case 'Select':
-                node.wordlist.forEach((word) => walkWord(word, visitScript));
-                visitNode(node.body);
-                break;
-            case 'ArithmeticFor':
-                if (node.initialize)
-                    walkArithmetic(node.initialize, visitScript);
-                if (node.test)
-                    walkArithmetic(node.test, visitScript);
-                if (node.update)
-                    walkArithmetic(node.update, visitScript);
-                visitNode(node.body);
-                break;
-            case 'While':
-                visitNode(node.clause);
-                visitNode(node.body);
-                break;
-            case 'Function':
-                walkWord(node.name, visitScript);
-                visitNode(node.body);
-                break;
-            case 'Subshell':
-            case 'BraceGroup':
-                visitNode(node.body);
-                break;
-            case 'CompoundList':
-                node.commands.forEach(visitNode);
-                break;
-            case 'Case':
-                walkWord(node.word, visitScript);
-                node.items.forEach((item) => {
-                    item.pattern.forEach((word) => walkWord(word, visitScript));
-                    visitNode(item.body);
-                });
-                break;
-            case 'Coproc':
-                walkWord(node.name, visitScript);
-                visitNode(node.body);
-                break;
-            case 'TestCommand':
-                walkTest(node.expression, visitScript);
-                break;
-            case 'ArithmeticCommand':
-                if (node.expression)
-                    walkArithmetic(node.expression, visitScript);
-                break;
-        }
-    };
-    try {
-        const parsed = parse(source);
-        if (parsed.errors?.length) {
-            return {
-                programs: [],
-                occurrences: [],
-                diagnostics: parsed.errors.map((error) => `${error.pos}: ${error.message}`),
-            };
-        }
-        visitScript(parsed);
-    }
-    catch (error) {
-        diagnostics.push(error instanceof Error ? error.message : String(error));
-    }
-    return { programs, occurrences, diagnostics };
-}

package/dist/lib/session/state.d.ts

@@ -1,269 +0,0 @@
-/**
- * Session state inference.
- *
- * Turns a chronological slice of normalized `SessionEvent`s (typically the tail
- * of a transcript) plus lightweight context (file mtime, cwd, branch, whether
- * the owning process is alive) into a `SessionState`: is the agent working,
- * waiting on the user, or idle — and did it open a PR, is it in a worktree, is
- * it tied to a tracker ticket. Pure functions, no I/O, so the whole thing is
- * unit-testable and shared by both the live `--active` path and the incremental
- * scanner (which persists the durable signals to the index).
- *
- * Structural signals are preferred over prose heuristics: Claude's
- * `ExitPlanMode` / `AskUserQuestion` tool calls are exact "waiting on you"
- * markers. Codex has no such tools, so it falls back to last-role + question
- * shape + mtime — same function, driven off the normalized events.
- */
-import type { SessionAttachment, SessionEvent, TodoItem, TodoProgress } from './types.js';
-import { type ProducedArtifact } from './highlights.js';
-export type { TodoItem, TodoProgress };
-export type SessionActivity = 'working' | 'waiting_input' | 'idle';
-/**
- * Why a session is `waiting_input`. The state engine produces `question` and
- * `plan_review` from transcript structure. `permission` is NOT inferred from a
- * transcript any more (PHNX-3999): a tool call with no result looks the same
- * whether the tool is still running or a permission dialog is up, and only the
- * harness's own `permission_prompt` hook event (the feed block) can tell them
- * apart. The value stays in the union because a row from a peer running an older
- * CLI can still carry it; the attention reconciler treats such a row as an
- * unverified claim, never as an approvable request.
- */
-export type AwaitingReason = 'question' | 'plan_review' | 'permission';
-/** One discrete choice the agent offered the user. */
-export interface QuestionOption {
-    /** The choice label — also what a free-text reply channel sends back. */
-    label: string;
-    /** Optional longer description shown under the label. */
-    description?: string;
-    /**
-     * Selection keystroke for an interactive TUI prompt (AskUserQuestion / plan /
-     * permission are select-lists, not text inputs): a digit ('1'), or 'esc' to
-     * cancel/deny. Absent for a plain prose question, which takes free text.
-     */
-    key?: string;
-}
-/**
- * The decision an agent handed back to the user, extracted at the SOURCE so every
- * consumer (Factory panel, teams, cloud) gets the real question + options instead
- * of re-deriving them from a truncated preview line. `reason` mirrors
- * {@link AwaitingReason}; `options` is present when the agent offered discrete choices.
- */
-export interface StructuredQuestion {
-    /**
-     * The question itself — the trailing ask, not the whole message. For a prose
-     * question this is the extracted trailing question block (see
-     * {@link extractProseQuestion}); for a structured harness question it is the
-     * agent-supplied question text, unchanged.
-     */
-    text: string;
-    reason: AwaitingReason;
-    options?: QuestionOption[];
-    /**
-     * Optional preceding prose for a prose question — the report/explanation that
-     * came BEFORE the trailing ask, with its Markdown and newlines preserved so a
-     * consumer can render it as context under the question. Absent for a structured
-     * harness question and when a prose question carries no preceding context.
-     */
-    context?: string;
-}
-export interface DetectedPr {
-    url: string;
-    number?: number;
-    /** `gh pr view` status, attached by the feed watch when it has fetched it. */
-    state?: string;
-    isDraft?: boolean;
-    reviewDecision?: string;
-    mergeable?: string;
-    /** The check rollup folded to one verdict. */
-    checks?: 'passing' | 'failing' | 'pending';
-}
-export interface DetectedWorktree {
-    /** Absolute worktree path (the session cwd). */
-    path: string;
-    /** The `<slug>` under `.agents/worktrees/`. */
-    slug: string;
-    branch?: string;
-}
-export interface DetectedTicket {
-    /** Tracker key, e.g. `RUSH-1234`. */
-    id: string;
-    url?: string;
-}
-/**
- * Detect per-session rate-limit / usage-limit signals in assistant or error
- * text (RUSH-1523). Matches the same shapes the ext's prewarm detectBlockingPrompt
- * uses, plus common Claude/Codex/Gemini limit strings.
- */
-export declare function detectRateLimited(text?: string): boolean;
-export interface SessionState {
-    activity: SessionActivity;
-    awaitingReason?: AwaitingReason;
-    lastRole?: 'user' | 'assistant';
-    lastEventKind?: SessionEvent['type'];
-    /** Single-line description of the latest turn (message text or tool action). */
-    preview?: string;
-    /**
-     * True when the transcript shows the session is rate/usage limited (RUSH-1523).
-     * Distinct from account-level usageStatus — this is per-session evidence.
-     */
-    rateLimited?: boolean;
-    /**
-     * The structured decision the agent is waiting on (question / plan / permission),
-     * with its options when it offered any. Set only when activity is waiting_input.
-     */
-    question?: StructuredQuestion;
-    /**
-     * The plan markdown from the most recent `ExitPlanMode` tool call, surfaced
-     * when `awaitingReason === 'plan_review'`. The state engine detects the
-     * handoff off the same tool event; carrying the plan text alongside it lets
-     * consumers (the Factory NEEDS-YOU panel, `agents sessions <id> --json`)
-     * render the actual plan without re-parsing the transcript.
-     */
-    plan?: string;
-    /**
-     * Live plan progress from the most recent `TodoWrite` (RUSH-1380). Present when
-     * the session has written a todo list; drives the Fleet N/M pill +
-     * checklist, notably for remote/device-dispatched agents with no local stream.
-     */
-    todos?: TodoProgress;
-    /** Durable documents created in the bounded transcript slice. */
-    artifacts?: ProducedArtifact[];
-    /** First created plan document, for consumers that give plans special treatment. */
-    planFile?: string;
-    /** Last few assistant turns (most-recent last), one line each — panel context. */
-    tail?: string[];
-    lastActivityMs?: number;
-    /**
-     * Timestamp (ms) of the last meaningful transcript event — a message, tool
-     * call, tool result, thinking block, or error — when the harness stamped one
-     * (PHNX-3999). This is the transcript's own cursor: unlike the file mtime it does
-     * not move when the harness appends a hook-firing record or other bookkeeping
-     * line, so it is the evidence that the agent did (or did not) work past a given
-     * moment — what the attention reconciler compares a hook-raised prompt against.
-     */
-    lastEventMs?: number;
-    pr?: DetectedPr;
-    worktree?: DetectedWorktree;
-    ticket?: DetectedTicket;
-    /** Tracker refs this session CREATED (Linear create_issue / gh issue create). */
-    createdTickets?: string[];
-    /** Team name this session SPAWNED via `agents teams create/add`. */
-    spawnedTeam?: string;
-    /** Displayable files/screenshots attached to the session prompt. */
-    attachments?: SessionAttachment[];
-}
-interface StateContext {
-    /** Session file mtime; drives running-vs-stale. */
-    mtimeMs?: number;
-    cwd?: string;
-    gitBranch?: string;
-    /** Whether the owning OS process is alive (from the active scanner). */
-    pidAlive?: boolean;
-    /** Override the running window (defaults to 2 min, matching active.ts). */
-    activeWindowMs?: number;
-    /**
-     * The clock every elapsed-time signal is measured against (default `Date.now()`).
-     * Injected so a cached parse can be re-classified against the CURRENT time — a
-     * time-based verdict (the prose-question decay) must expire even when the
-     * transcript bytes have not changed (PHNX-3999).
-     */
-    nowMs?: number;
-}
-/**
- * Derive live plan progress from a checklist tool call's args. Accepts Claude's
- * `TodoWrite` (`todos: [{content,status,activeForm}]`), Kimi's `TodoList`
- * (`todos: [{title,status}]`, where finished is `done` rather than `completed`)
- * and Codex's `update_plan` (`plan: [{step,status}]`) shapes, so the CLI is the
- * single source of checklist state for every agent. Returns undefined when there
- * is no usable list, so a session with no plan carries no `todos` field.
- */
-export declare function extractTodoProgress(args?: Record<string, any>): TodoProgress | undefined;
-/** Fold snapshot checklist tools and Claude TaskCreate/TaskUpdate event logs. */
-export declare function extractTodoProgressFromEvents(events: SessionEvent[]): TodoProgress | undefined;
-/** Derive a recency-ordered, de-duplicated list of directories touched by tools. */
-export declare function extractRecentDirectoriesTouched(events: SessionEvent[], cwd?: string): string[] | undefined;
-export declare const WORKTREE_RE: RegExp;
-/** Detect a worktree from the session cwd, per the `.agents/worktrees/<slug>/` convention. */
-export declare function detectWorktree(cwd?: string, branch?: string): DetectedWorktree | undefined;
-/** Detect a tracker ticket from free text (prompt/topic) then a branch name. */
-export declare function detectTicket(text?: string, branch?: string): DetectedTicket | undefined;
-/** Pull a PR URL + number out of tool-result output text. */
-export declare function extractPrUrl(output?: string): DetectedPr | undefined;
-/** True when a Bash/exec command string is a `gh pr create`. */
-export declare function isPrCreateCommand(command?: string): boolean;
-/**
- * The team a session SPAWNED, from an `agents teams create/add <name>` command.
- * Returns the team name, or undefined if the command isn't a team spawn. Note this
- * is the opposite of `isTeamOrigin` (which marks sessions spawned BY a team).
- */
-export declare function detectSpawnedTeam(command?: string): string | undefined;
-/**
- * True when a tool_use call CREATES a tracker ticket — a Linear MCP `create_issue`
- * tool, or a Bash `gh issue create`. The created id is then read from the matching
- * tool_result via {@link extractCreatedTicket}.
- */
-export declare function isTicketCreateTool(name?: string, command?: string): boolean;
-/**
- * Pull a created ticket ref out of a create-issue tool_result. Linear returns a
- * key like `RUSH-1234`; `gh issue create` returns the issue URL, from which we
- * take `#<number>`. Returns undefined when neither shape is present.
- */
-export declare function extractCreatedTicket(text?: string): string | undefined;
-/**
- * Structured question from a Claude `AskUserQuestion` tool call. Its input is
- * `{ questions: [{ question, header, options: [{label, description}] }] }` and the
- * whole thing is already parsed onto `event.args` by the transcript parser — this
- * surfaces the first question + its options (instead of collapsing to a generic
- * "Asked you a question"). The prompt is a select-list, so each option carries its
- * 1-based selection digit as `key`.
- */
-export declare function structuredQuestionFromAsk(args?: Record<string, any>): StructuredQuestion | undefined;
-/** The separated question the CLI shows: the trailing ask + optional preceding context. */
-export interface ProseQuestion {
-    /** The trailing ask, with its original Markdown and line breaks. */
-    text: string;
-    /** The preceding report/explanation, Markdown + newlines preserved; absent when none. */
-    context?: string;
-}
-/**
- * Split a run of prose into its trailing QUESTION and the CONTEXT before it,
- * instead of flattening a whole report into one line (the old `oneLine(content)`
- * that copied a merged report and lost its Markdown). Returns undefined when the
- * text has no real trailing ask.
- *
- * Rules, each pinned by a test:
- *   - The ask must be TRAILING: the last eligible non-empty line is the question,
- *     or the search stops (a report line after the question means it isn't the ask).
- *   - A `?` that lives ONLY inside a fenced code block, an inline `code` span, or a
- *     `>` blockquote does NOT count — those lines are ineligible to end the ask
- *     (they still ride along in `context`).
- *   - Multiple/multiline related asks are kept together (a contiguous run of
- *     question / list-item / `:`-lead-in lines), never dropped.
- *   - When the ask shares ONE line with preceding prose, the leading non-question
- *     sentences peel into `context` and only the trailing question sentence(s) stay
- *     in `text`.
- *   - Both fields preserve newlines and Markdown.
- */
-export declare function extractProseQuestion(raw: string): ProseQuestion | undefined;
-/**
- * Infer live activity + a preview from a chronological event slice. `pr` /
- * `ticket` / `worktree` are attached by `inferSessionState`; this focuses on the
- * running-vs-waiting-vs-idle decision and the preview line.
- */
-export declare function inferActivity(events: SessionEvent[], ctx?: StateContext): SessionState;
-/**
- * Scan an event slice for the durable signals that aren't about the cwd: the PR
- * opened, the injected ticket, plus the artifacts the session PRODUCED — tracker
- * refs it created and any team it spawned. Each `gh pr create` / create-issue tool
- * call is correlated with the nearest following tool_result; the team name comes
- * straight off the `agents teams create/add` command.
- */
-export declare function detectDurableSignals(events: SessionEvent[]): {
-    pr?: DetectedPr;
-    ticket?: DetectedTicket;
-    createdTickets?: string[];
-    spawnedTeam?: string;
-    attachments?: SessionAttachment[];
-};
-/** Full inference: activity + preview + durable signals + worktree/ticket from ctx. */
-export declare function inferSessionState(events: SessionEvent[], ctx?: StateContext): SessionState;