team 0.0.1 → 0.1.0

package/dist/launch/plan.js

@@ -0,0 +1,280 @@
+import { join } from 'node:path';
+import { profileFor } from "../profiles/index.js";
+import { launchCommand, shellQuote } from "../profiles/profile.js";
+/** The variables a herdr server starts with: nothing else reaches a seat's pane. */
+export const SERVER_ENVIRONMENT = ['HOME', 'USER', 'LOGNAME', 'PATH', 'SHELL', 'TERM', 'LANG'];
+/** `herdr` aimed at a session; herdr's default session takes no option. */
+export function herdr(session, ...args) {
+    return session === 'default' ? ['herdr', ...args] : ['herdr', '--session', session, ...args];
+}
+/** What stands for a pane id that only exists once its workspace is created. */
+export function paneOf(label) {
+    return `<pane of ${label}>`;
+}
+/** Every step of `team up`, in order. Nothing here runs anything. */
+export function upPlan(input) {
+    const { session } = input;
+    const steps = [];
+    if (!input.sessionRunning) {
+        steps.push({
+            kind: 'run',
+            argv: ['env', '-i', ...SERVER_ENVIRONMENT.map((name) => `${name}=$${name}`), ...herdr(session, 'server')],
+            note: 'detached, in a clean environment; SSH_AUTH_SOCK is passed too when it is set',
+            do: { do: 'server', session },
+        });
+        steps.push({
+            kind: 'wait',
+            text: `until session ${session} is running (30 s at most)`,
+            do: { do: 'wait-session', session, seconds: 30 },
+        });
+    }
+    const lobbies = new Set();
+    for (const seat of input.seats) {
+        if (seat.stopped) {
+            steps.push({ kind: 'skip', text: `${seat.name}: stopped in the file; start it with \`team add ${seat.name}\`` });
+            continue;
+        }
+        const profile = profileFor(seat.cli);
+        if (!profile) {
+            steps.push({
+                kind: 'skip',
+                text: `${seat.name}: no launch profile for \`${seat.cli}\` in this version; left out`,
+            });
+            continue;
+        }
+        if (seat.stage === 'ready') {
+            steps.push({ kind: 'skip', text: `${seat.name}: already ready; left as it is` });
+            continue;
+        }
+        const pane = seat.pane ?? paneOf(seat.label);
+        const cwd = join(input.root, seat.cwd);
+        const fresh = seat.stage === undefined || !seat.pane;
+        // The same condition as the launch step below. A seat already running keeps
+        // its idle wait, rename and rules, and hears the reading as a notice.
+        const wouldLaunch = fresh || (seat.stage === 'launched' && !seat.agentLive);
+        if (seat.budget?.kind === 'refuse' && wouldLaunch) {
+            steps.push({
+                kind: 'skip',
+                text: `${seat.name}: would refuse: ${seat.budget.why}`,
+                do: { do: 'refuse', seat: seat.name, why: seat.budget.why },
+            });
+            continue;
+        }
+        let notice;
+        if (seat.budget?.kind === 'unknown')
+            notice = seat.budget.text;
+        else if (seat.budget?.kind === 'refuse')
+            notice = seat.budget.why;
+        const takeNotice = () => {
+            const text = notice;
+            notice = undefined;
+            return text;
+        };
+        if (fresh) {
+            // The lobby is one folder for the team, made before the first seat waits in it.
+            if (seat.lobby && !lobbies.has(cwd)) {
+                lobbies.add(cwd);
+                steps.push({
+                    kind: 'run',
+                    argv: ['mkdir', '-p', cwd],
+                    note: 'the lobby: where a seat that works in worktrees waits, outside every protected checkout',
+                    do: { do: 'lobby', path: cwd },
+                });
+            }
+            const said = takeNotice();
+            steps.push({
+                kind: 'run',
+                argv: herdr(session, 'workspace', 'create', '--cwd', cwd, '--label', seat.label, '--no-focus'),
+                ...(said ? { note: `${said}; would launch` } : {}),
+                do: { do: 'create', seat: seat.name, label: seat.label, cwd, ...(said ? { notice: said } : {}) },
+            });
+        }
+        const command = launchCommand(profile, seat.launch, seat.rules);
+        if (fresh || (seat.stage === 'launched' && !seat.agentLive)) {
+            const said = takeNotice();
+            steps.push({
+                kind: 'run',
+                argv: herdr(session, 'pane', 'run', pane, command),
+                ...(said ? { note: `${said}; would launch` } : {}),
+                do: { do: 'launch', seat: seat.name, label: seat.label, command, pane: seat.pane, ...(said ? { notice: said } : {}) },
+            });
+        }
+        const rules = profile.rulesOption === null ? 'message' : 'option';
+        if (seat.stage !== 'named') {
+            const said = takeNotice();
+            steps.push({
+                kind: 'wait',
+                text: `until ${seat.name} shows its idle prompt (${profile.idleTimeout} s at most); ` +
+                    'anything else is reported, its workspace closed without input, and the seat left out',
+                ...(said ? { note: said } : {}),
+                do: {
+                    do: 'idle',
+                    seat: seat.name,
+                    label: seat.label,
+                    cli: seat.cli,
+                    seconds: profile.idleTimeout,
+                    pane: seat.pane,
+                    workspace: seat.workspace,
+                    ...(said ? { notice: said } : {}),
+                },
+            });
+            steps.push({
+                kind: 'run',
+                argv: herdr(session, 'agent', 'rename', pane, seat.name),
+                do: { do: 'rename', seat: seat.name, label: seat.label, seconds: profile.idleTimeout, rules, pane: seat.pane },
+            });
+        }
+        if (profile.rulesOption === null) {
+            const said = takeNotice();
+            steps.push({
+                kind: 'run',
+                argv: herdr(session, 'pane', 'send-text', pane, seat.rules),
+                note: said
+                    ? `${said}; the rules, only at an empty idle prompt; re-read before Enter, then wait for working with empty input`
+                    : 'the rules, only at an empty idle prompt; re-read before Enter, then wait for working with empty input',
+                do: {
+                    do: 'deliver',
+                    seat: seat.name,
+                    label: seat.label,
+                    cli: seat.cli,
+                    rules: seat.rules,
+                    seconds: profile.idleTimeout,
+                    pane: seat.pane,
+                    ...(said ? { notice: said } : {}),
+                },
+            });
+        }
+        else if (seat.stage === 'named') {
+            const said = takeNotice();
+            steps.push({
+                kind: 'skip',
+                text: `${seat.name}: named, and its rules went with the launch; marked ready`,
+                ...(said ? { note: said } : {}),
+                do: { do: 'ready', seat: seat.name, rules: 'option', ...(said ? { notice: said } : {}) },
+            });
+        }
+    }
+    if (input.watchAlive)
+        return steps;
+    const watchArguments = session === 'default' ? '' : ` --session ${shellQuote(session)}`;
+    const watchLine = input.watchLine ?? `team watch${watchArguments}`;
+    steps.push({
+        kind: 'run',
+        argv: herdr(session, 'workspace', 'create', '--cwd', input.root, '--label', 'watchdog', '--no-focus'),
+        do: { do: 'create', label: 'watchdog', cwd: input.root },
+    });
+    steps.push({
+        kind: 'run',
+        argv: herdr(session, 'pane', 'run', paneOf('watchdog'), watchLine),
+        note: 'a desktop notification follows when the watch exits',
+        do: { do: 'watch', label: 'watchdog', command: watchLine },
+    });
+    return steps;
+}
+const LEFT = {
+    working: 'is working (`--wait` waits for it)',
+    blocked: 'is blocked at a prompt, which `team` never answers',
+    unknown: 'shows a screen the profile does not recognise',
+    unsent: 'holds unsent text in its input box',
+};
+/** Every step of `team down`, in order. Nothing here runs anything. */
+export function downPlan(input) {
+    const { session } = input;
+    const steps = [];
+    let left = input.extra;
+    for (const seat of input.seats) {
+        if (input.keep.includes(seat.name)) {
+            steps.push({
+                kind: 'skip',
+                text: `${seat.name}: left running; only the owner stops the coordinator's or the operator's seat`,
+            });
+            left++;
+            continue;
+        }
+        const profile = profileFor(seat.cli);
+        if (!profile) {
+            if (input.abandon) {
+                steps.push({
+                    kind: 'run',
+                    argv: herdr(session, 'workspace', 'close', seat.workspace),
+                    note: 'abandoned: nothing was typed',
+                    do: { do: 'close', seat: seat.name, workspace: seat.workspace },
+                });
+                continue;
+            }
+            steps.push({
+                kind: 'skip',
+                text: `${seat.name}: no launch profile for \`${seat.cli}\` in this version; left running`,
+            });
+            left++;
+            continue;
+        }
+        if (seat.state !== 'free') {
+            if (input.abandon) {
+                steps.push({
+                    kind: 'run',
+                    argv: herdr(session, 'workspace', 'close', seat.workspace),
+                    note: 'abandoned: nothing was typed',
+                    do: { do: 'close', seat: seat.name, workspace: seat.workspace },
+                });
+                continue;
+            }
+            steps.push({ kind: 'skip', text: `${seat.name}: ${LEFT[seat.state]}; left running` });
+            left++;
+            continue;
+        }
+        // The printed command is `pane run`. The live step types with `typeText` and `pressEnter`:
+        // `/exit` has to go into the idle prompt, and the screen is read again before the Enter.
+        steps.push({
+            kind: 'run',
+            argv: herdr(session, 'pane', 'run', seat.pane, profile.exit),
+            do: { do: 'type', seat: seat.name, pane: seat.pane, text: profile.exit },
+        });
+        steps.push({
+            kind: 'wait',
+            text: `until ${seat.name}'s pane is back at its shell (${profile.exitTimeout} s at most); on a time-out it is left as it is`,
+            do: { do: 'gone', seat: seat.name, pane: seat.pane, seconds: profile.exitTimeout },
+        });
+        steps.push({
+            kind: 'run',
+            argv: herdr(session, 'workspace', 'close', seat.workspace),
+            do: { do: 'close', seat: seat.name, workspace: seat.workspace },
+        });
+    }
+    if (input.watchPid !== null) {
+        steps.push({
+            kind: 'run',
+            argv: ['kill', String(input.watchPid)],
+            note: 'the watch',
+            do: { do: 'kill', pid: input.watchPid },
+        });
+    }
+    if (session === 'default') {
+        steps.push({ kind: 'skip', text: "session default: herdr's default session is never stopped" });
+    }
+    else if (left > 0) {
+        steps.push({
+            kind: 'skip',
+            text: `session ${session}: not stopped, ${left} agent${left === 1 ? '' : 's'} left in it`,
+        });
+    }
+    else {
+        steps.push({ kind: 'run', argv: ['herdr', 'session', 'stop', session], do: { do: 'stop', session } });
+    }
+    return steps;
+}
+/** The plan as `--dry-run` prints it. */
+export function formatPlan(steps) {
+    const lines = steps.map((step) => {
+        if (step.kind === 'run') {
+            const command = step.argv
+                .map((word) => (/^<pane of .+>$|^[A-Z_]+=\$[A-Z_]+$/.test(word) ? word : shellQuote(word)))
+                .join(' ');
+            return `+ ${command}${step.note ? `\n    (${step.note})` : ''}`;
+        }
+        if (step.kind === 'wait')
+            return `  wait ${step.text}${step.note ? `\n    (${step.note})` : ''}`;
+        return `  skip ${step.text}${step.note ? `\n    (${step.note})` : ''}`;
+    });
+    return `${lines.join('\n')}\ndry run: nothing was run\n`;
+}

package/dist/launch/rules.d.ts

@@ -0,0 +1,25 @@
+/** What the rules of a seat are written from. */
+export interface RulesInput {
+    coordinator: string;
+    /** The file's own `rules`. */
+    rules: readonly string[];
+    /** The seat's signature lines, already rendered. */
+    signature: {
+        commit: string;
+        pullRequest: string;
+        commitPosition: 'last-line' | 'trailer' | 'anywhere';
+    };
+    workspace: {
+        mode: 'worktree' | 'shared';
+        protected: readonly string[];
+        branch?: string;
+    };
+}
+/**
+ * The rules a seat gets at launch, one per line, in this order: the profile's
+ * own (what `team` itself depends on), the file's, the seat's signature, the
+ * workspace's.
+ */
+export declare function seatRules(input: RulesInput): string[];
+/** The rules as the one text a launch option or a first message carries. */
+export declare function rulesText(input: RulesInput): string;

package/dist/launch/rules.js

@@ -0,0 +1,36 @@
+const COMMIT_PLACE = {
+    trailer: 'as a trailer, in a last paragraph of its own that holds trailers only',
+    'last-line': 'as its last line',
+    anywhere: 'on a line of its own',
+};
+/**
+ * The rules a seat gets at launch, one per line, in this order: the profile's
+ * own (what `team` itself depends on), the file's, the seat's signature, the
+ * workspace's.
+ */
+export function seatRules(input) {
+    const { signature, workspace } = input;
+    const own = [
+        'End every commit message and every pull request body with your signature, given below.',
+        `Never stop at a question: tell the coordinator (${input.coordinator}) in one line and keep working.`,
+        'Never run `team trust` or `team approve`, and never edit `trust:` in the team file.',
+        'In a protected checkout, never switch the branch, reset or commit.',
+    ];
+    const signing = [
+        `Your signature in a commit message, ${COMMIT_PLACE[signature.commitPosition]}: ${signature.commit}`,
+        `Your signature in a pull request body, as its last line: ${signature.pullRequest}`,
+    ];
+    const working = [];
+    if (workspace.protected.length > 0) {
+        working.push(`Protected checkouts, relative to the project root: ${workspace.protected.join(', ')}`);
+    }
+    if (workspace.mode === 'worktree') {
+        working.push('Work on the code in the worktree your brief names, never in the checkout you started in.' +
+            (workspace.branch ? ` Branches are named ${workspace.branch}.` : ''));
+    }
+    return [...own, ...input.rules, ...signing, ...working];
+}
+/** The rules as the one text a launch option or a first message carries. */
+export function rulesText(input) {
+    return ['Rules for this session, from the team file:', ...seatRules(input).map((rule) => `- ${rule}`)].join('\n');
+}

package/dist/log.d.ts

@@ -0,0 +1 @@
+export declare function logLine(dir: string, command: string, caller: string, what: string, now?: Date): void;

package/dist/log.js

@@ -0,0 +1,24 @@
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { LOG_FILE } from "./state.js";
+const MAX_BYTES = 1_000_000;
+const KEPT = 3;
+// One line per change: when, which command, called by whom, what changed. Classifications only,
+// never the text of a screen. The log rotates at 1 MB and keeps three files.
+export function logLine(dir, command, caller, what, now = new Date()) {
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, LOG_FILE);
+    if (existsSync(path) && statSync(path).size >= MAX_BYTES)
+        rotate(path);
+    appendFileSync(path, `${now.toISOString()} ${command} [${caller}] ${what.replace(/\s+/g, ' ')}\n`);
+}
+function rotate(path) {
+    const oldest = `${path}.${KEPT - 1}`;
+    if (existsSync(oldest))
+        unlinkSync(oldest);
+    for (let n = KEPT - 2; n >= 1; n--) {
+        if (existsSync(`${path}.${n}`))
+            renameSync(`${path}.${n}`, `${path}.${n + 1}`);
+    }
+    renameSync(path, `${path}.1`);
+}

package/dist/profiles/antigravity.yaml

@@ -0,0 +1,66 @@
+# Antigravity's screen. Trust and permission are case-insensitive. The slash
+# menu's arrow line and the esc footer are chrome, so exit-typed stays unsent.
+format: 1
+cli: antigravity
+binary: agy
+process_names:
+  - agy
+tested:
+  from: '1.2.16'
+  to: '1.2.16'
+unattended:
+  - --dangerously-skip-permissions
+rules: first-message
+login:
+  check:
+    - models
+  hint: agy
+exit: /exit
+timeouts:
+  idle: 90s
+  exit: 30s
+models:
+  option:
+    - --model
+  ids:
+    - match: '^gemini-([0-9]+(?:\.[0-9]+)?)-(flash|pro)(?:-(high|medium|low))?$'
+      ignore_case: true
+      model: 'Gemini {2:title}'
+      version: '{1}'
+status_model:
+  - match: '(?:^|[\s·|])Gemini\s+([0-9]+(?:\.[0-9]+)*)\s+(Flash|Pro)\b'
+    ignore_case: true
+    model: 'Gemini {2:title}'
+    version: '{1}'
+screen:
+  chrome:
+    - '^\s*↑/↓ Navigate.*$'
+    - '^esc to cancel\s+Gemini\s+[0-9].*$'
+  trust:
+    ignore_case: true
+    rules:
+      - all:
+          - 'Do you trust the contents of this project\?'
+          - '>\s*Yes, I trust this folder'
+        below_last_rule: 'enter Confirm'
+  permission:
+    ignore_case: true
+    rules:
+      - all:
+          - 'Requesting permission for:'
+          - '^\s*>\s*[0-9]\.\s+Yes\b'
+        below_last_rule: '↑/↓ Navigate'
+  working:
+    - any: ['\bGenerating\.\.\.']
+  composer:
+    mode: two-rules-footer-below
+    ignore_case: true
+    prompt: '^\s*>\s*'
+    rule: '^\s*[─━]{8,}\s*$'
+    footers:
+      - '\? for shortcuts'
+      - 'Gemini\s+[0-9]'
+      - 'esc to cancel'
+      - '>\s*/exit\s+Exit'
+    placeholders:
+      - equals: ''

package/dist/profiles/claude-code.yaml

@@ -0,0 +1,69 @@
+# Claude Code's screen. The questions are written out in both cases: the old
+# classifier ignored case on those two lines and not on the "1. Yes" choice, and
+# ignore_case would apply to the whole rule.
+format: 1
+cli: claude-code
+binary: claude
+process_names:
+  - claude
+tested:
+  from: '2.1.288'
+  to: '2.1.288'
+unattended:
+  - --dangerously-skip-permissions
+rules:
+  option: --append-system-prompt
+login:
+  check:
+    - auth
+    - status
+  hint: claude auth login
+exit: /exit
+timeouts:
+  idle: 90s
+  exit: 30s
+models:
+  option:
+    - --model
+  ids:
+    - match: '^claude-(opus|sonnet|haiku|fable)-([0-9]+)-([0-9]{1,2})(?:-[0-9]{8})?$'
+      model: 'Claude {1:title}'
+      version: '{2}.{3}'
+    - match: '^claude-(opus|sonnet|haiku|fable)-([0-9]+)(?:-[0-9]{8})?$'
+      model: 'Claude {1:title}'
+      version: '{2}'
+status_model:
+  - match: '(?:^|[\s·|])(Opus|Sonnet|Haiku|Fable)\s+([0-9]+(?:\.[0-9]+)*)(?:$|[\s·|])'
+    model: 'Claude {1}'
+    version: '{2}'
+screen:
+  trust:
+    - all:
+        - '(?:[Dd][Oo] [Yy][Oo][Uu] [Tt][Rr][Uu][Ss][Tt] (?:[Tt][Hh][Ii][Ss]|[Tt][Hh][Ee]) [Ff][Oo][Ll][Dd][Ee][Rr]\?|[Oo][Nn][Ee] [Yy][Oo][Uu] [Tt][Rr][Uu][Ss][Tt]\?)'
+        - '^\s*[❯›>]?\s*1\.\s+Yes\b'
+  # A quoted question above the composer's rule is not a dialog. The footer is the
+  # captured last line and needs the question. A Yes/No choice below the last rule
+  # is the other shape; the mark is optional, as on an unmarked "2. No".
+  permission:
+    - all:
+        - 'Do you want to (proceed|make this edit|create|allow)'
+      footer: 'Esc to cancel · Tab to amend'
+      below_last_rule: 'Esc to cancel · Tab to amend'
+    - below_last_rule: '^\s*❯?\s*[0-9]\. (Yes|No)\b'
+  question:
+    - any:
+        - 'Enter to select'
+        - '↑/↓ to navigate'
+        - 'Enter to confirm'
+        - 'Esc to cancel'
+  working:
+    - any:
+        - '\besc to interrupt\b'
+        - '^[^\S\n]*[✢✳✶✻✼✽][^\n]*…\s*\(\s*\d'
+  composer:
+    mode: box-to-rule
+    prompt: '^\s*[❯›>]'
+    rule: '^\s*[─━]{8,}'
+    placeholders:
+      - equals: ''
+      - prefix: 'Try "'

package/dist/profiles/codex.yaml

@@ -0,0 +1,77 @@
+# Codex's screen. An empty box is idle, as the old classifier treated it; the
+# grey suggestion is the other placeholder.
+format: 1
+cli: codex
+binary: codex
+process_names:
+  - codex
+tested:
+  from: '0.157.0'
+  to: '0.157.0'
+unattended:
+  - -a
+  - never
+  - -s
+  - danger-full-access
+  - --no-daemon
+  - --no-alt-screen
+rules: first-message
+login:
+  check:
+    - login
+    - status
+  hint: codex login
+exit: /exit
+timeouts:
+  idle: 90s
+  exit: 30s
+models:
+  option:
+    - -m
+    - --model
+  ids:
+    - match: '^gpt-([0-9]+(?:\.[0-9]+)?)-(astra|sol|luna|terra)$'
+      ignore_case: true
+      model: 'GPT {2:title}'
+      version: '{1}'
+quota:
+  - account: openai
+    match: '\bweekly ([0-9]+)% left\b'
+    left: '{1}%'
+    window: weekly
+status_model:
+  - match: '^\s+GPT-([0-9]+(?:\.[0-9]+)?)-([Aa][Ss][Tt][Rr][Aa]|[Ss][Oo][Ll]|[Ll][Uu][Nn][Aa]|[Tt][Ee][Rr][Rr][Aa])\s[^·]*·'
+    model: 'GPT {2:title}'
+    version: '{1}'
+  # A later footer that is not one of those four names is unread, as the old id map was.
+  - match: '^\s+GPT-[0-9][\w.-]*\s[^·]*·'
+    model: '{1}'
+    version: '{1}'
+screen:
+  unknown:
+    - any: ['\bmodel:\s+loading\b']
+  trust:
+    - all:
+        - 'Trust this folder\?'
+        - '^\s*›?\s*1\. Trust and continue\s*$'
+      footer: 'enter continue · esc quit'
+  permission:
+    - all:
+        - '^\s*Would you like to run the following command\?\s*$'
+        - '^\s*›?\s*1\. Yes, proceed \(y\)\s*$'
+        - '^\s*›?\s*2\. No, and tell Codex what to do differently \(esc\)\s*$'
+      footer: 'Press enter to confirm or esc to cancel'
+  question:
+    - all:
+        - 'Update available ·'
+        - '^\s*›?\s*1\. Update now\b'
+      footer: 'enter continue · esc skip'
+  working:
+    - any: ['esc to interrupt']
+  composer:
+    mode: status-last
+    status_line: '^\s+GPT-[0-9][\w.-]*\s+[^·]*·'
+    prompt: '^\s*›(?:\s|$)'
+    placeholders:
+      - equals: ''
+      - equals: Ask Codex to do anything

package/dist/profiles/cursor.yaml

@@ -0,0 +1,68 @@
+# Cursor's screen. "To resume this session:" is unknown, and the core reads
+# unknown before trust. The braille range is written as characters: \u is refused.
+format: 1
+cli: cursor
+binary: cursor-agent
+process_names:
+  - cursor-agent
+tested:
+  from: '2026.10.01'
+  to: '2026.10.01'
+unattended:
+  - --force
+  - --sandbox
+  - disabled
+rules: first-message
+login:
+  check:
+    - status
+  hint: cursor-agent login
+exit: /exit
+timeouts:
+  idle: 90s
+  exit: 30s
+models:
+  option:
+    - --model
+  ids:
+    - match: '^(?:cursor-)?grok-([0-9]+(?:\.[0-9]+)*)(?:-(?:xhigh|high|medium|low)(?:-fast)?|-fast)?$'
+      ignore_case: true
+      model: Grok
+      version: '{1}'
+status_model:
+  - match: '(?:^|\s)Grok\s+([0-9]+(?:\.[0-9]+)*)\b'
+    model: Grok
+    version: '{1}'
+screen:
+  unknown:
+    - any: ['To resume this session:']
+  trust:
+    - all:
+        - 'Do you trust the contents of this'
+        - 'directory\?'
+        - '\[a\] Trust this workspace'
+        - '\[q\] Quit'
+      none_after:
+        anchor: 'Use arrow keys to navigate, Enter to'
+        patterns:
+          - '^\s*→'
+          - '^\s+Grok\s+[0-9]'
+  working:
+    - any:
+        - 'ctrl\+c to stop'
+        - '^\s*[⠀-⣿]+\s+(Working|Thinking)\b'
+  composer:
+    mode: status-then-one
+    status_line: '^\s+Grok\s+[0-9]'
+    prompt: '^\s*→'
+    strip_suffix: '\s*ctrl\+c to stop\s*$'
+    placeholders:
+      - equals: ''
+      - equals: Plan, search, build anything
+      - equals: Add a follow-up
+    fallback:
+      - all:
+          - match: '^\s*→\s+\S'
+            except: ['\sExit\s*$']
+          - '^\s*→?\s*/\S+\s+Exit\s*$'
+        kind: unsent

package/dist/profiles/index.d.ts

@@ -0,0 +1 @@
+export { profileFor } from './profile.ts';

package/dist/profiles/index.js

@@ -0,0 +1 @@
+export { profileFor } from "./profile.js";