@sickr/cli 0.9.6 → 0.9.8

package/dist/cli.js

@@ -11,8 +11,9 @@ import { buildSharePayload, buildCombinedPayload, publish, PublishError } from '
 import { AUTH_ENDPOINT, readCredentials, writeCredentials, clearCredentials, startDevice, pollDevice, sleep } from './auth.js';
 import { ui, card, kv } from './ui.js';
 import { AGENT_API_URL, clearAgentCredentials, disconnectAgent, fetchAgentStatus, pollAgentConnect, readAgentCredentials, rotateAgentKey, startAgentConnect, writeAgentCredentials, } from './agentAuth.js';
+import { PROVIDERS, recordCommandFor } from './providers.js';
 const REPLAY_ENDPOINT = process.env.SICKR_REPLAY_ENDPOINT ?? 'https://sickr.ai/api/replay';
-const COMMANDS = ['init', 'record', 'open', 'list', 'share', 'stop', 'clear', 'login', 'logout', 'whoami', 'agent', 'live', 'run', 'replay', 'workflow', 'help'];
+const COMMANDS = ['init', 'record', 'open', 'list', 'share', 'stop', 'clear', 'login', 'logout', 'whoami', 'agent', 'live', 'run', 'replay', 'prime', 'workflow', 'start', 'status', 'help'];
 export function parseCommand(argv) {
     const c = argv[0];
     return c && COMMANDS.includes(c) ? c : null;
@@ -26,7 +27,7 @@ export function replaySubcommand(rest) {
     }
     return null;
 }
-export function workflowAgentAlias(rest) {
+export function primeAgentAlias(rest) {
     const sub = rest[0];
     if (sub === 'connect' || sub === 'rotate' || sub === 'disconnect')
         return [...rest];
@@ -35,7 +36,7 @@ export function workflowAgentAlias(rest) {
 function withoutFirst(rest) {
     return rest.slice(1);
 }
-export function buildWorkflowInvocation(rest, command = 'uvx') {
+export function buildPrimeInvocation(rest, command = 'uvx') {
     const sub = rest[0] ?? 'status';
     const tail = withoutFirst(rest);
     if (sub === 'start') {
@@ -51,121 +52,92 @@ export function buildWorkflowInvocation(rest, command = 'uvx') {
     }
     return { command, args: rest };
 }
-export const HELP = `SICKR Replay — audit & replay what your AI coding agent did.
+export const workflowAgentAlias = primeAgentAlias;
+export const buildWorkflowInvocation = buildPrimeInvocation;
+export function runtimeConfigSummary(config) {
+    const modeLabel = {
+        replay: 'Replay',
+        live: 'Live',
+        run: 'Run',
+        prime_workflow: 'Prime Workflow',
+    };
+    const provider = PROVIDERS[config.provider];
+    return `${config.agent_id}: ${modeLabel[config.mode]} on ${provider.displayName}`;
+}
+function providerFromFlags(args) {
+    if (args.includes('--codex'))
+        return 'codex';
+    if (args.includes('--gemini'))
+        return 'gemini';
+    if (args.includes('--cursor'))
+        return 'cursor';
+    if (args.includes('--local'))
+        return 'local';
+    return 'claude';
+}
+export const HELP = `sickr - replay, live view, remote control, and Prime Workflow for AI coding agents.
 
-Records your Claude Code or Codex session (prompts, edits, commands) to a local,
-redacted timeline you can replay — and optionally share as a public link.
+Usage: npx @sickr/cli <command> [options]
 
-Why: a durable record of every agent action — a dashcam for your coding agent.
-If your agent (Claude or Codex) loses context or can't reload a past chat, the
-replay log helps you — and it — recall exactly what was just done.
+ACCOUNT
+  login               Sign in with GitHub.
+  logout              Forget the local login.
+  whoami              Show who you're signed in as.
 
-Usage: npx @sickr/cli <command> [options]
+START HERE
+  start --agent-id <id>
+                      Fetch the configured runtime from workflow.sickr.ai
+                      and start the right mode for that agent: Prime Workflow,
+                      Run, Live, or Replay.
+
+REPLAY (free) - local recording of every prompt, edit and command.
+  replay              Install Claude + Codex recording hooks. Use the agents
+                      as normal - a redacted timeline is captured to
+                      ~/.sickr/runs.
+  replay open [id]    Render the newest run as a local HTML timeline.
+  replay share [id]   Publish a redacted run to sickr.ai/r/<id>.
+  replay list         List recorded runs, newest first.
+  replay stop         Remove sickr hooks from this project.
+  replay clear        Delete all local runs in ~/.sickr/runs.
 
-Commands:
-  replay        Auto mode: installs Claude + Codex recording hooks. If the
-                signed-in user has Replay Pro, starts Live Look as well.
-  replay init all|claude|codex
-                Install recording hooks under the unified command name.
-  replay share  Publish a redacted replay to sickr.ai/r/<id>.
-  replay status Show Live Look sidecar status.
-  workflow connect --agent-id <id>
-                Connect this machine to a configured SICKR workflow agent.
-  workflow start --agent-id <id>
-                Start the workflow orchestrator for that configured agent.
-  workflow status
-                Show running workflow daemon status.
-  workflow rotate | workflow disconnect
-                Rotate or revoke this machine's workflow agent key.
+LIVE ($9) - passive streaming to a watching browser.
+  live                Stream events to sickr.ai/r/<your-link>. Browser text is
+                      queued to ~/.sickr/inbox/<urlid>.md; it does not control
+                      an already-running agent.
+  live status         Show pid + connection state.
+  live stop           Stop the sidecar.
 
-Legacy replay commands remain supported:
-  init <agent>   Install recording hooks for an agent (REQUIRED — no default)
-                 and start capturing to ~/.sickr/runs (secrets redacted):
-                   claude    Claude Code  (.claude/settings.json)
-                   codex     Codex        (.codex/hooks.json — needs Codex 0.133+)
-                   all       both of the above (feeds the combined view)
-                 Flag: --no-name  (label prompts "Human", not your login name)
-  open [run]     Render a run to a local HTML timeline and open it. 100% local.
-                 Defaults to the newest run; pass a run id, or --codex/--claude
-                 for the newest run of that agent. Combine across agents with a
-                 window: --today, --since <2h|30m|1d>, or --all (interleaved,
-                 filterable by agent, sortable by prompt/response time).
-  share [run]    Redact and publish ONE run to a public sickr.ai/r/<id> link
-                 (shows a preview and asks first). Links expire after 24h.
-                   --open    also open the published link in your browser
-                   --yes     skip the confirmation prompt
-                 Or publish a COMBINED multi-agent view with a window:
-                 --today / --since <2h|30m|1d> / --all (+ --claude/--codex).
-  list           List recorded runs, newest first.
-  stop           Stop recording — removes SICKR's hooks from this project.
-                 Your recorded runs are kept; run \`init\` to start again.
-  clear          Delete all local runs in ~/.sickr/runs (asks first).
-  login          Sign in with GitHub (optional — unlocks persistent shares and
-                 Replay Pro cohort eligibility). Zero-account use still works.
-  logout         Forget the local login. Server-side session stays valid until
-                 it expires; revoke from your account page if needed.
-  whoami         Show who you're logged in as.
-  live           Replay Pro: stream the current session to sickr.ai/r/<your-link>
-                 in real time. Requires \`login\` and Replay Pro entitlement.
-                   replay live            start the sidecar (foreground; ^C exits)
-                   replay live status     show pid + connection state
-                   replay live stop       stop the sidecar
-                 While running, steer messages from the watching browser are
-                 saved to ~/.sickr/inbox/<urlid>.md and printed in your terminal.
-  run <agent>    Replay Pro (Phase 2): wrap an agent in a PTY this CLI owns.
-                 Browser steer messages land directly in the agent's stdin —
-                 real remote control, no copy-paste from inbox.
-                   sickr run claude         spawn Claude Code under sickr (auto-perms)
-                   sickr run codex          same for Codex (auto-perms)
-                   sickr run <bin>          arbitrary command
-                 Modes:
-                   --mode auto  (default)   inject the agent's "no prompt /
-                                            full permissions" flag so it
-                                            doesn't stall on tool confirms
-                                            the operator can't see (claude:
-                                            --dangerously-skip-permissions;
-                                            codex: --dangerously-bypass-
-                                            approvals-and-sandbox)
-                   --mode interactive       pass agent flags through verbatim;
-                                            agent will prompt for tool use
-                 \`node-pty\` ships as an optional dep + auto-installs with the
-                 CLI on supported platforms (mac, Linux, Windows 10+).
-                 Browsers can override per-message: {mode:'queue'|'steer',
-                 submit:true|false}; default is auto-steer with submit.
-  agent connect --agent-id <id>
-                 Connect this machine to a configured SICKR agent using GitHub
-                 browser approval. Stores the agent key in ~/.sickr/agent.json.
-  agent status  Show the connected agent, org and team.
-  agent rotate  Rotate this machine's agent key.
-  agent disconnect
-                 Revoke this machine's agent key and remove it locally.
-  help           Show this help.
+RUN ($12) - remote control from the browser.
+  run <agent>         Wrap an agent in a PTY sickr owns; browser steer messages
+                      are written directly into the agent's stdin.
+                        sickr run claude
+                        sickr run codex
+                        sickr run gemini
+                        sickr run cursor-agent
+                        sickr run <bin>
+                      Flags: --mode auto (default) | --mode interactive
 
-Requires Node 18+. Codex capture needs Codex CLI 0.133+ (run /hooks to trust);
-Claude Code: any hooks-capable build.
+PRIME WORKFLOW - governed ticket execution.
+  prime connect --agent-id <id>      Approve this machine for a configured
+                                     Prime Workflow agent.
+  prime start   --agent-id <id>      Start PRIME for an agent.
+  prime status                       Show running daemon status.
+  prime stop                         Stop the local PRIME daemon.
+  prime rotate | disconnect          Rotate or revoke this machine's key.
 
-────────────────────────────────────────────────────────────────────
-This replays your AI coding agents on ONE machine. SICKR governs your whole team.
-Issue tracking + your team + automation + agents — one governed workflow for
-audit, accountability, productivity and confidence.
+Product modes are ordered: Prime Workflow > Run > Live > Replay.
+Prime Workflow runs PRIME for agentic or hybrid teams: plan, review,
+implement, merge, evaluate, and ship under control.
 
-  · Gates & approvals — work holds at plan sign-off, review, merge and
-    validation checks until each one passes.
-  · Humans + agents on one board — agents are first-class teammates with
-    roles, capacity and accountability, not a side channel.
-  · A full, signed-off audit trail across every actor and every change.
-  · Runs 24/7 — produce as much work as you like; the team handles it.
+Requires Node 20+. Codex capture needs Codex CLI 0.133+ and one manual
+/hooks trust approval. Gemini/Cursor/local runners are adapter-backed and
+may have provider-specific setup prompts.
 
-  Free tier available · bring your own Claude or Codex subscription.
-  → https://sickr.ai
+https://sickr.ai
 `;
 export function currentRunId(cc) {
     return String(cc.session_id ?? 'session');
 }
-const PROVIDERS = {
-    claude: { name: 'Claude Code', label: 'Claude', settingsPath: () => join(process.cwd(), '.claude', 'settings.json') },
-    codex: { name: 'Codex', label: 'Codex', settingsPath: () => join(process.cwd(), '.codex', 'hooks.json') },
-};
 function configPath() {
     return join(homedir(), '.sickr', 'config.json');
 }
@@ -199,7 +171,7 @@ function resolveName() {
 export function handleRecord(input, provider = 'claude') {
     try {
         const cc = JSON.parse(input);
-        appendEvent(currentRunId(cc), cc, { human: resolveName(), agent: PROVIDERS[provider].label });
+        appendEvent(currentRunId(cc), cc, { human: resolveName(), agent: PROVIDERS[provider].recordLabel });
     }
     catch {
         /* swallow: recording is best-effort and must not disrupt the session */
@@ -207,9 +179,13 @@ export function handleRecord(input, provider = 'claude') {
 }
 export function handleInit(provider, noName = false) {
     const p = PROVIDERS[provider];
+    if (!p.supportsHooks || !p.settingsPath) {
+        process.stdout.write(`sickr: ${p.displayName} does not use SICKR hooks. Use \`sickr run ${p.defaultCommand}\` or \`sickr start --agent-id <id>\`.\n`);
+        return;
+    }
     const settingsPath = p.settingsPath();
     const settings = existsSync(settingsPath) ? JSON.parse(readFileSync(settingsPath, 'utf8')) : {};
-    const command = `npx @sickr/cli record${provider === 'codex' ? ' --codex' : ''}`;
+    const command = recordCommandFor(provider);
     // Remove any prior SICKR hook first, then install the current command — so
     // re-running init (or a CLI upgrade that changes the command) self-heals
     // instead of leaving a stale hook. Scoped to this provider's file.
@@ -222,16 +198,16 @@ export function handleInit(provider, noName = false) {
     const name = noName ? 'Human' : loginName();
     writeFileSync(configPath(), JSON.stringify({ name }, null, 2) + '\n');
     const labelLine = `Your prompts will be labelled "${name}"${noName ? '' : ' — run `init --no-name` to anonymize'}.\n`;
-    const nextSteps = provider === 'codex'
-        ? 'Next: in Codex, run `/hooks` to review & trust these hooks (Codex gates new hooks),\nthen use Codex as normal and: npx @sickr/cli replay open --codex\n'
-        : 'Use Claude Code as normal, then: npx @sickr/cli replay open\n';
-    process.stdout.write(`sickr: installed ${p.name} recording hooks in ${settingsPath}\n` +
+    const nextSteps = p.requiresManualHookTrust
+        ? `Next: in ${p.displayName}, trust the SICKR recorder when prompted (Codex uses \`/hooks\`),\nthen use the agent as normal and: npx @sickr/cli replay open\n`
+        : `Use ${p.displayName} as normal, then: npx @sickr/cli replay open\n`;
+    process.stdout.write(`sickr: installed ${p.displayName} recording hooks in ${settingsPath}\n` +
         `Runs are recorded locally to ${runsDir()} (secrets redacted).\n` +
         labelLine + nextSteps);
 }
 /** Stop recording: remove SICKR's hooks from this project (both providers), keep runs. */
 export function handleStop() {
-    const targets = [PROVIDERS.claude.settingsPath(), PROVIDERS.codex.settingsPath()];
+    const targets = Object.values(PROVIDERS).filter((p) => p.supportsHooks && p.settingsPath).map((p) => p.settingsPath());
     const cleaned = [];
     for (const settingsPath of targets) {
         if (!existsSync(settingsPath))
@@ -316,9 +292,9 @@ export function latestRunIdFor(agent) {
 function handleOpen(runId, provider) {
     let id = runId;
     if (!id && provider) {
-        id = latestRunIdFor(PROVIDERS[provider].label) ?? undefined;
+        id = latestRunIdFor(PROVIDERS[provider].recordLabel) ?? undefined;
         if (!id) {
-            process.stdout.write(`sickr: no ${PROVIDERS[provider].label} runs yet — use ${PROVIDERS[provider].name} with the hooks installed, then try again.\n`);
+            process.stdout.write(`sickr: no ${PROVIDERS[provider].recordLabel} runs yet - use ${PROVIDERS[provider].displayName} with the hooks installed, then try again.\n`);
             return;
         }
     }
@@ -403,11 +379,11 @@ function handleList(provider) {
     const dir = runsDir();
     let files = existsSync(dir) ? readdirSync(dir).filter((f) => f.endsWith('.ndjson')) : [];
     if (provider) {
-        const want = PROVIDERS[provider].label;
+        const want = PROVIDERS[provider].recordLabel;
         files = files.filter((f) => loadRun(f.replace(/\.ndjson$/, '')).events.some((e) => e.kind === 'response' && e.label === want));
     }
     if (files.length === 0) {
-        process.stdout.write(provider ? `sickr: no ${PROVIDERS[provider].label} runs yet.\n` : 'sickr: no runs yet.\n');
+        process.stdout.write(provider ? `sickr: no ${PROVIDERS[provider].recordLabel} runs yet.\n` : 'sickr: no runs yet.\n');
         return;
     }
     files
@@ -471,7 +447,7 @@ function expiryCopy(ttl_days) {
         return {
             kind: 'pro',
             value: `${ttl_days} days`,
-            tag: 'Replay Pro',
+            tag: 'paid retention',
             footer: [],
         };
     if (ttl_days >= 2)
@@ -487,7 +463,7 @@ function expiryCopy(ttl_days) {
         tag: 'anon link',
         footer: [
             'run `npx @sickr/cli login` to extend new links to 7 days.',
-            'Replay Pro (live + remote) — early access, rolling cohorts:',
+            'Live ($9) and Run ($12) - early access, rolling cohorts:',
             '  https://sickr.ai/#waitlist',
         ],
     };
@@ -504,7 +480,7 @@ function tipLine(text) {
 }
 function legacyExpiryLine(ttl_days) {
     if (ttl_days >= 30)
-        return `sickr: this link is live for ${ttl_days} days (Replay Pro retention).\n`;
+        return `sickr: this link is live for ${ttl_days} days (paid retention).\n`;
     if (ttl_days >= 2)
         return `sickr: this link is live for ${ttl_days} days — re-share before it expires to extend.\n`;
     return `sickr: this link expires in 24h. Run \`npx @sickr/cli login\` to extend to 7 days.\n`;
@@ -552,7 +528,7 @@ async function handleShare(runId, yes, open) {
     else {
         process.stdout.write(`sickr: published → ${url}\n` +
             legacyExpiryLine(ttl_days) +
-            (exp.kind === 'anon' ? `sickr: Replay Pro (live + remote) — early access, rolling out in cohorts → https://sickr.ai/#waitlist\n` : ''));
+            (exp.kind === 'anon' ? `sickr: Live ($9) and Run ($12) - early access, rolling out in cohorts -> https://sickr.ai/#waitlist\n` : ''));
     }
     if (open)
         openInBrowser(url);
@@ -605,7 +581,7 @@ async function handleShareCombined(sel, yes, open) {
     else {
         process.stdout.write(`sickr: published → ${url}\n` +
             legacyExpiryLine(ttl_days) +
-            (exp.kind === 'anon' ? `sickr: Replay Pro (live + remote) — early access, rolling out in cohorts → https://sickr.ai/#waitlist\n` : ''));
+            (exp.kind === 'anon' ? `sickr: Live ($9) and Run ($12) - early access, rolling out in cohorts -> https://sickr.ai/#waitlist\n` : ''));
     }
     if (open)
         openInBrowser(url);
@@ -860,6 +836,24 @@ async function fetchReplayProEntitlement() {
         return false;
     }
 }
+/** Gate a Pro-only command. Returns true if the user is allowed; otherwise
+ *  prints a friendly explanation and returns false. Distinguishes the three
+ *  failure modes (not-logged-in / logged-in-no-pro / network-fail) so the
+ *  operator knows exactly what to do next. */
+async function requireReplayPro(commandLabel) {
+    const creds = readCredentials();
+    if (!creds) {
+        process.stderr.write(`sickr: \`${commandLabel}\` requires a paid Live, Run, or Prime Workflow entitlement.\n` +
+            `       run \`sickr login\` first — your Pro entitlement is attached to your GitHub account.\n`);
+        return false;
+    }
+    if (await fetchReplayProEntitlement())
+        return true;
+    process.stderr.write(`sickr: \`${commandLabel}\` requires a paid Live, Run, or Prime Workflow entitlement.\n` +
+        `       you are signed in as ${creds.login}, but this account does not have access yet.\n` +
+        `       join the rolling-cohort waitlist -> https://sickr.ai/#waitlist\n`);
+    return false;
+}
 async function handleReplay(rest) {
     const sub = replaySubcommand(rest);
     if (!sub) {
@@ -876,11 +870,11 @@ async function handleReplay(rest) {
             handleInit('codex', noName);
             return;
         }
-        if (agent === 'claude' || agent === 'codex') {
+        if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'cursor' || agent === 'local') {
             handleInit(agent, noName);
             return;
         }
-        process.stderr.write('sickr: choose an agent - `sickr replay init claude`, `codex`, or `all`.\n');
+        process.stderr.write('sickr: choose an agent - `sickr replay init claude`, `codex`, `gemini`, or `all`.\n');
         process.exit(1);
         return;
     }
@@ -901,12 +895,12 @@ async function handleReplay(rest) {
             handleOpenCombined(sel);
             return;
         }
-        const openProvider = replayRest.includes('--codex') ? 'codex' : replayRest.includes('--claude') ? 'claude' : undefined;
+        const openProvider = replayRest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(replayRest) : undefined;
         handleOpen(replayRest.find((a) => !a.startsWith('-')), openProvider);
         return;
     }
     if (sub === 'list') {
-        const listProvider = replayRest.includes('--codex') ? 'codex' : replayRest.includes('--claude') ? 'claude' : undefined;
+        const listProvider = replayRest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(replayRest) : undefined;
         handleList(listProvider);
         return;
     }
@@ -933,6 +927,10 @@ async function handleReplay(rest) {
             liveStatus();
             return;
         }
+        if (!(await requireReplayPro('sickr replay live'))) {
+            process.exit(3);
+            return;
+        }
         await startLive({ verbose: replayRest.includes('--verbose') || replayRest.includes('-v'), background: replayRest.includes('--background') });
         return;
     }
@@ -943,7 +941,7 @@ async function handleReplay(rest) {
         return;
     }
     process.stdout.write('sickr: replay recording is ready for Claude and Codex.\n' +
-        '       Replay Pro unlocks live viewing with `sickr replay live`.\n');
+        '       Live unlocks browser viewing; Run unlocks browser control.\n');
 }
 function commandCandidates(mappedArgs) {
     const override = process.env.SICKR_ORCHESTRATOR_CMD?.trim();
@@ -957,8 +955,8 @@ function commandCandidates(mappedArgs) {
         { command: 'python', args: ['-m', 'labudi_orchestrator.cli', ...mappedArgs] },
     ];
 }
-function runWorkflow(rest) {
-    const mapped = buildWorkflowInvocation(rest).args;
+function runPrime(rest) {
+    const mapped = buildPrimeInvocation(rest).args;
     const candidates = commandCandidates(mapped);
     let lastStatus = 1;
     for (const candidate of candidates) {
@@ -968,18 +966,18 @@ function runWorkflow(rest) {
             continue;
         }
         if (result.error) {
-            process.stderr.write(`sickr: workflow command failed to start: ${result.error.message}\n`);
+            process.stderr.write(`sickr: prime command failed to start: ${result.error.message}\n`);
             process.exit(1);
             return;
         }
         process.exit(result.status ?? 0);
         return;
     }
-    process.stderr.write('sickr: workflow orchestrator is not available. Install Python package `sickr` with `uv tool install sickr`, or set SICKR_ORCHESTRATOR_CMD.\n');
+    process.stderr.write('sickr: Prime Workflow orchestrator is not available. Install Python package `sickr` with `uv tool install sickr`, or set SICKR_ORCHESTRATOR_CMD.\n');
     process.exit(lastStatus);
 }
-async function handleWorkflow(rest) {
-    const alias = workflowAgentAlias(rest);
+async function handlePrime(rest) {
+    const alias = primeAgentAlias(rest);
     if (alias) {
         const sub = alias[0];
         const agentRest = alias.slice(1);
@@ -996,7 +994,7 @@ async function handleWorkflow(rest) {
             return;
         }
     }
-    runWorkflow(rest.length ? rest : ['status']);
+    runPrime(rest.length ? rest : ['status']);
 }
 export async function readStreamWithIdle(input, idleMs = 250, emptyMs = 1500) {
     const chunks = [];
@@ -1041,7 +1039,7 @@ async function main() {
     }
     const cmd = parseCommand(argv);
     const rest = argv.slice(1);
-    const provider = rest.includes('--codex') ? 'codex' : 'claude';
+    const provider = providerFromFlags(rest);
     switch (cmd) {
         case 'record':
             handleRecord(await readStdin(), provider);
@@ -1054,11 +1052,11 @@ async function main() {
                 handleInit('codex', noName);
                 return;
             }
-            if (agent === 'claude' || agent === 'codex') {
+            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'cursor' || agent === 'local') {
                 handleInit(agent, noName);
                 return;
             }
-            process.stderr.write('sickr: choose an agent — `init claude`, `init codex`, or `init all`.\n');
+            process.stderr.write('sickr: choose an agent - `init claude`, `init codex`, `init gemini`, or `init all`.\n');
             process.exit(1);
             return;
         }
@@ -1068,12 +1066,12 @@ async function main() {
                 handleOpenCombined(sel);
                 return;
             }
-            const openProvider = rest.includes('--codex') ? 'codex' : rest.includes('--claude') ? 'claude' : undefined;
+            const openProvider = rest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(rest) : undefined;
             handleOpen(rest.find((a) => !a.startsWith('-')), openProvider);
             return;
         }
         case 'list': {
-            const listProvider = rest.includes('--codex') ? 'codex' : rest.includes('--claude') ? 'claude' : undefined;
+            const listProvider = rest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(rest) : undefined;
             handleList(listProvider);
             return;
         }
@@ -1095,8 +1093,17 @@ async function main() {
         case 'replay':
             await handleReplay(rest);
             return;
+        case 'prime':
+            await handlePrime(rest);
+            return;
         case 'workflow':
-            await handleWorkflow(rest);
+            await handlePrime(rest);
+            return;
+        case 'start':
+            await handlePrime(['start', ...rest]);
+            return;
+        case 'status':
+            await handlePrime(['status', ...rest]);
             return;
         case 'agent': {
             const sub = rest[0];
@@ -1132,6 +1139,10 @@ async function main() {
                 liveStatus();
                 return;
             }
+            if (!(await requireReplayPro('sickr live'))) {
+                process.exit(3);
+                return;
+            }
             // default: start (foreground)
             const opts = { verbose: rest.includes('--verbose') || rest.includes('-v'), background: rest.includes('--background') };
             await startLive(opts);
@@ -1180,6 +1191,10 @@ async function main() {
             const passthroughFlags = flags.filter((f) => f !== '--verbose' && f !== '-v');
             const agentArgs = [...passthroughFlags, ...positional.slice(1)];
             const verbose = flags.includes('--verbose') || flags.includes('-v');
+            if (!(await requireReplayPro('sickr run'))) {
+                process.exit(3);
+                return;
+            }
             const { startRun } = await import('./run.js');
             try {
                 await startRun({ agent, agentArgs, verbose, mode });

package/dist/live.js

@@ -136,7 +136,7 @@ export async function startLive(opts = {}) {
         urlid = await computeUrlid(creds);
     }
     catch (e) {
-        process.stderr.write(`sickr: couldn't resolve live url (${e.message}). Replay Pro required.\n`);
+        process.stderr.write(`sickr: couldn't resolve live url (${e.message}). Live entitlement required.\n`);
         try {
             unlinkSync(pidPath());
         }

package/dist/providers.js

@@ -0,0 +1,85 @@
+import { join } from 'node:path';
+export const PROVIDERS = {
+    claude: {
+        provider: 'claude',
+        displayName: 'Claude Code',
+        recordLabel: 'Claude',
+        defaultCommand: 'claude',
+        supportsHooks: true,
+        requiresManualHookTrust: false,
+        supportsPtyControl: true,
+        supportsStructuredStream: false,
+        settingsPath: () => join(process.cwd(), '.claude', 'settings.json'),
+        notes: 'Hooks are installed into .claude/settings.json and Claude reads them without an extra trust command.',
+    },
+    codex: {
+        provider: 'codex',
+        displayName: 'Codex',
+        recordLabel: 'Codex',
+        defaultCommand: 'codex',
+        supportsHooks: true,
+        requiresManualHookTrust: true,
+        supportsPtyControl: true,
+        supportsStructuredStream: false,
+        settingsPath: () => join(process.cwd(), '.codex', 'hooks.json'),
+        recordFlag: '--codex',
+        notes: 'Codex requires the user to type /hooks once and trust the SICKR recorder.',
+    },
+    gemini: {
+        provider: 'gemini',
+        displayName: 'Gemini CLI',
+        recordLabel: 'Gemini',
+        defaultCommand: 'gemini',
+        supportsHooks: true,
+        requiresManualHookTrust: true,
+        supportsPtyControl: true,
+        supportsStructuredStream: false,
+        settingsPath: () => join(process.cwd(), '.gemini', 'settings.json'),
+        recordFlag: '--gemini',
+        notes: 'Gemini CLI has a hooks surface; SICKR keeps it behind an adapter so trust behavior can be handled per release.',
+    },
+    cursor: {
+        provider: 'cursor',
+        displayName: 'Cursor CLI',
+        recordLabel: 'Cursor',
+        defaultCommand: 'cursor-agent',
+        supportsHooks: false,
+        requiresManualHookTrust: false,
+        supportsPtyControl: true,
+        supportsStructuredStream: true,
+        notes: 'Cursor is best captured through headless stream-json for workflow jobs; interactive control uses the PTY wrapper.',
+    },
+    local: {
+        provider: 'local',
+        displayName: 'Local LLM',
+        recordLabel: 'Local',
+        defaultCommand: 'sickr-local-agent',
+        supportsHooks: false,
+        requiresManualHookTrust: false,
+        supportsPtyControl: true,
+        supportsStructuredStream: true,
+        notes: 'Local models should run through a SICKR-owned harness against Ollama, vLLM, llama.cpp, or an OpenAI-compatible endpoint.',
+    },
+};
+export function providerForAgent(agent) {
+    const a = agent.toLowerCase();
+    const base = a.replace(/^.*[\\/]/, '').replace(/\.(cmd|exe|bat|com)$/i, '');
+    if (base === 'claude')
+        return 'claude';
+    if (base === 'codex')
+        return 'codex';
+    if (base === 'gemini')
+        return 'gemini';
+    if (base === 'cursor' || base === 'cursor-agent')
+        return 'cursor';
+    if (base === 'ollama' || base === 'vllm' || base === 'llama.cpp' || base === 'llama-server' || base === 'sickr-local-agent')
+        return 'local';
+    return null;
+}
+export function recordCommandFor(provider) {
+    const p = PROVIDERS[provider];
+    return `npx @sickr/cli record${p.recordFlag ? ` ${p.recordFlag}` : ''}`;
+}
+export function modeRank(mode) {
+    return { replay: 0, live: 1, run: 2, prime_workflow: 3 }[mode];
+}

package/dist/run.js

@@ -29,6 +29,7 @@ import { readCredentials } from './auth.js';
 import { runsDir } from './recorder.js';
 import { mergeHooks, removeHooks } from './hookConfig.js';
 import { LIVE_BASE, decodeWsPayload, splitJsonObjects } from './live.js';
+import { PROVIDERS, providerForAgent, recordCommandFor } from './providers.js';
 /** Resolve the agent binary path. Precedence:
  *    1. SICKR_AGENT_BIN_<NAME> env (e.g. SICKR_AGENT_BIN_CLAUDE)
  *    2. <NAME>_BIN env (e.g. CLAUDE_BIN)
@@ -182,12 +183,13 @@ function tailFrom(path, from) {
  *  hooks were ensured / installed; false if the agent name isn't
  *  one we know how to init for. */
 export function ensureRecordingHooks(agent) {
-    const provider = agent === 'claude' || agent === 'codex' ? agent : null;
+    const provider = providerForAgent(agent);
     if (!provider)
         return false; // Custom binaries — caller decides whether to install hooks
-    const settingsPath = provider === 'codex'
-        ? join(process.cwd(), '.codex', 'hooks.json')
-        : join(process.cwd(), '.claude', 'settings.json');
+    const adapter = PROVIDERS[provider];
+    if (!adapter.supportsHooks || !adapter.settingsPath)
+        return false;
+    const settingsPath = adapter.settingsPath();
     let existing = {};
     if (existsSync(settingsPath)) {
         try {
@@ -208,7 +210,7 @@ export function ensureRecordingHooks(agent) {
     // Dynamic import keeps the file from pulling hookConfig at module
     // load (tiny boot perf + lets tests run without the module).
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const command = `npx @sickr/cli record${provider === 'codex' ? ' --codex' : ''}`;
+    const command = recordCommandFor(provider);
     const merged = mergeHooks(removeHooks(existing), command);
     mkdirSync(join(settingsPath, '..'), { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n');
@@ -272,7 +274,7 @@ export async function startRun(opts) {
         urlid = await computeUrlid(creds);
     }
     catch (e) {
-        process.stderr.write(`sickr: couldn't resolve live url (${e.message}). Replay Pro required.\n`);
+        process.stderr.write(`sickr: couldn't resolve live url (${e.message}). Run entitlement required.\n`);
         process.exit(4);
     }
     // Ensure recording hooks are installed in the cwd for known agents.
@@ -295,6 +297,11 @@ export async function startRun(opts) {
     else if (mode === 'interactive') {
         process.stdout.write(`       mode=interactive — agent will prompt for tool use; you confirm in the PTY\n`);
     }
+    if (opts.agent === 'codex') {
+        // Codex 0.133+ gates new hooks until trusted; without trust the recorder
+        // is dormant and /r/<urlid> stays empty even though the PTY is live.
+        process.stdout.write(`       codex hooks: type \`/hooks\` once inside codex to trust the recorder.\n`);
+    }
     process.stdout.write(`       browser steer messages land directly in your agent. ^C exits.\n\n`);
     const pty = ptySpawn(agentBin, effectiveArgs, {
         name: 'xterm-256color',
@@ -388,12 +395,28 @@ export async function startRun(opts) {
                 if (m.kind === 'steer' && m.text) {
                     const decision = decideSteer(m);
                     if (decision.target === 'pty' && decision.bytes != null) {
+                        // Submit-fix (2026-06-01): Claude Code's TUI treats a burst of
+                        // characters arriving with no inter-keystroke gap as a paste
+                        // — and within a paste, \r is an inline newline, NOT a submit.
+                        // Text appeared in the input box but never got sent until the
+                        // operator manually hit Enter. Split the write: body first,
+                        // then a short delay, then a standalone \r so it lands as a
+                        // discrete Enter keypress instead of "tail of a paste".
+                        const bytes = decision.bytes;
+                        const bodyOnly = bytes.endsWith('\r') ? bytes.slice(0, -1) : bytes;
+                        const submit = bytes.endsWith('\r');
                         try {
-                            pty.write(decision.bytes);
+                            if (bodyOnly.length > 0)
+                                pty.write(bodyOnly);
+                            if (submit)
+                                setTimeout(() => { try {
+                                    pty.write('\r');
+                                }
+                                catch { /* pty exited */ } }, 80);
                         }
                         catch { /* PTY may have exited */ }
                         if (opts.verbose)
-                            process.stderr.write(`sickr: pty steer ${decision.bytes.length}b\n`);
+                            process.stderr.write(`sickr: pty steer ${bytes.length}b${submit ? ' (split for submit)' : ''}\n`);
                     }
                     else {
                         appendInbox(urlid, m.text, m.at ?? new Date().toISOString());

package/package.json

@@ -1,18 +1,27 @@
 {
   "name": "@sickr/cli",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "type": "module",
   "description": "npx @sickr/cli - replay, live look, and workflow orchestration for AI coding agents.",
-  "bin": { "replay": "dist/cli.js", "sickr": "dist/cli.js" },
-  "files": ["dist"],
-  "publishConfig": { "access": "public" },
+  "bin": {
+    "replay": "dist/cli.js",
+    "sickr": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsc",
     "test": "vitest run",
     "dev": "tsc -w",
     "prepublishOnly": "npm run build && npm test && node scripts/pre-publish-check.mjs"
   },
-  "engines": { "node": ">=20" },
+  "engines": {
+    "node": ">=20"
+  },
   "license": "UNLICENSED",
   "optionalDependencies": {
     "node-pty": "^1.0.0",