@sickr/cli 0.9.7 → 0.9.9

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,80 +52,92 @@ export function buildWorkflowInvocation(rest, command = 'uvx') {
     }
     return { command, args: rest };
 }
-export const HELP = `sickr — record, replay, and remote-control your AI coding agents.
+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.
 
 Usage: npx @sickr/cli <command> [options]
 
-REPLAY (free) — local recording of every prompt, edit and command.
+ACCOUNT
+  login               Sign in with GitHub.
+  logout              Forget the local login.
+  whoami              Show who you're signed in as.
+
+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
+                      as normal - a redacted timeline is captured to
                       ~/.sickr/runs.
-  replay open [id]    Render the newest run (or a specific id) as a local
-                      HTML timeline. Combine across agents with --today,
-                      --since <2h|30m|1d>, or --all (+ --claude / --codex).
-  replay share [id]   Publish a redacted run to sickr.ai/r/<id> (asks first).
-                      Add --yes to skip the prompt; --open to open after.
-                      Or combine a window: --today / --since <dur> / --all.
-                      Anon links live 24h; signed-in links live 7 days.
-  replay list         List recorded runs, newest first (+ --claude/--codex).
-  replay stop         Remove sickr hooks from this project (keeps runs).
-  replay clear        Delete all local runs in ~/.sickr/runs (asks first).
+  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.
 
-LIVE LOOK (Replay Pro) — passive streaming to a watching browser.
-  live                Stream the current session to sickr.ai/r/<your-link> in
-                      real time. Browser steer messages land in
-                      ~/.sickr/inbox/<urlid>.md and your terminal prints them.
-                      Requires \`sickr login\` + Replay Pro entitlement.
+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.
 
-REMOTE CONTROL (Replay Pro) — browser keystrokes drive the agent.
-  run <agent>         Wrap an agent in a PTY sickr owns; browser steer
-                      messages are written directly into the agent's stdin.
-                      Real remote control, not pasteboard.
-                        sickr run claude      Claude Code under sickr
-                        sickr run codex       Codex under sickr
-                        sickr run <bin>       arbitrary binary
-                      Flags:
-                        --mode auto   (default) inject the agent's
-                                      "no prompt / full perms" flag so it
-                                      doesn't stall on tool confirms the
-                                      operator can't see.
-                        --mode interactive  pass agent flags through
-                                      verbatim — agent prompts for tool use.
-                      Requires \`sickr login\` + Replay Pro entitlement.
-                      Codex 0.133+ needs \`/hooks\` typed once to trust the
-                      recorder; Claude is silent (hooks auto-installed).
+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
 
-ACCOUNT
-  login               Sign in with GitHub. Unlocks persistent shares
-                      (24h → 7d) and Replay Pro entitlement.
-  logout              Forget the local login.
-  whoami              Show who you're signed in as.
+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.
 
-WORKFLOW (sickr-managed agent + ticketing)
-  workflow connect --agent-id <id>   Approve this machine for a configured
-                                     workflow agent (GitHub browser flow).
-  workflow start   --agent-id <id>   Start the orchestrator for an agent.
-  workflow status                    Show running daemon status.
-  workflow rotate | disconnect       Rotate or revoke this machine's key.
+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.
 
-  help                Show this help.
+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.
 
-Requires Node 20+. Codex capture needs Codex CLI 0.133+.
-
-────────────────────────────────────────────────────────────────────
-sickr also governs your whole team — issue tracking + humans + agents on one
-board, gates & approvals, signed audit trail, runs 24/7. 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');
 }
@@ -158,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 */
@@ -166,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.
@@ -181,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))
@@ -275,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;
         }
     }
@@ -362,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
@@ -430,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)
@@ -446,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',
         ],
     };
@@ -463,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`;
@@ -511,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);
@@ -564,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);
@@ -826,15 +843,15 @@ async function fetchReplayProEntitlement() {
 async function requireReplayPro(commandLabel) {
     const creds = readCredentials();
     if (!creds) {
-        process.stderr.write(`sickr: \`${commandLabel}\` is a Replay Pro feature.\n` +
+        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}\` is a Replay Pro feature.\n` +
-        `       you are signed in as ${creds.login}, but your account isn't on Replay Pro.\n` +
-        `       join the rolling-cohort waitlist → https://sickr.ai/#waitlist\n`);
+    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) {
@@ -853,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;
     }
@@ -878,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;
     }
@@ -924,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();
@@ -938,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) {
@@ -949,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);
@@ -977,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 = [];
@@ -1022,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);
@@ -1035,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;
         }
@@ -1049,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;
         }
@@ -1076,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];

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/recorder.js

@@ -93,7 +93,8 @@ export function mapEvent(cc, now = new Date(), ctx = {}) {
     const rawSession = String(cc.session_id ?? '');
     const session = rawSession ? rawSession.slice(0, 12) : undefined;
     const agent = ctx.agent;
-    const base = { at, agent, session };
+    const runner = process.env.SICKR_RUN_INSTANCE ? process.env.SICKR_RUN_INSTANCE.slice(0, 36) : undefined;
+    const base = { at, agent, session, runner };
     switch (name) {
         case 'SessionStart':
             return { kind: 'start', label: 'Session', detail: redact(String(cc.cwd ?? '')), ...base };

package/dist/run.js

@@ -23,12 +23,14 @@
 import { readFileSync, writeFileSync, appendFileSync, mkdirSync, existsSync, readdirSync, statSync, openSync, readSync, closeSync, unlinkSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { setTimeout as sleep } from 'node:timers/promises';
 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)
@@ -110,6 +112,18 @@ function appendInbox(urlid, text, at) {
         writeFileSync(file, `# steer inbox — ${urlid}\n\n`);
     appendFileSync(file, `\n## ${at}\n\n${text}\n`);
 }
+function normTarget(s) {
+    return String(s ?? '').trim().toLowerCase();
+}
+export function steerMatchesRunner(msg, identity) {
+    if (msg.targetRunner)
+        return msg.targetRunner === identity.runner;
+    if (msg.targetSession)
+        return identity.sessions.has(msg.targetSession);
+    if (msg.targetAgent)
+        return normTarget(msg.targetAgent) === normTarget(identity.agent);
+    return true;
+}
 export function decideSteer(msg, defaultMode = 'pty') {
     const text = String(msg.text ?? '');
     if (!text)
@@ -182,12 +196,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 +223,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 +287,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.
@@ -280,6 +295,10 @@ export async function startRun(opts) {
     // browser /r/<urlid> stays empty until events flow.
     ensureRecordingHooks(opts.agent);
     const agentBin = resolveAgent(opts.agent);
+    const provider = providerForAgent(opts.agent);
+    const agentLabel = provider ? PROVIDERS[provider].recordLabel : opts.agent;
+    const runnerId = randomUUID();
+    const runnerIdentity = { agent: agentLabel, runner: runnerId, sessions: new Set() };
     const cols = process.stdout.columns ?? 80;
     const rows = process.stdout.rows ?? 24;
     // mode=auto (default) injects the agent's "no prompt / full perms" flag
@@ -305,7 +324,7 @@ export async function startRun(opts) {
         name: 'xterm-256color',
         cols, rows,
         cwd: process.cwd(),
-        env: process.env,
+        env: { ...process.env, SICKR_RUN_INSTANCE: runnerId, SICKR_RUN_AGENT: agentLabel },
     });
     // Wire stdio: parent stdin -> pty; pty -> parent stdout.
     if (process.stdin.isTTY)
@@ -377,7 +396,11 @@ export async function startRun(opts) {
             let opened = false;
             ws.addEventListener('open', () => {
                 opened = true;
-                tailTimer = setInterval(() => pumpNewLines(ws, offsets), 500);
+                try {
+                    ws.send(JSON.stringify({ kind: 'hello', agent: runnerIdentity.agent, runner: runnerIdentity.runner }));
+                }
+                catch { /* reconnect loop handles failures */ }
+                tailTimer = setInterval(() => pumpNewLines(ws, offsets, runnerIdentity), 500);
             });
             ws.addEventListener('message', (ev) => {
                 const raw = decodeWsPayload(ev.data);
@@ -391,6 +414,11 @@ export async function startRun(opts) {
                     return;
                 }
                 if (m.kind === 'steer' && m.text) {
+                    if (!steerMatchesRunner(m, runnerIdentity)) {
+                        if (opts.verbose)
+                            process.stderr.write(`sickr: ignored steer for another agent/session\n`);
+                        return;
+                    }
                     const decision = decideSteer(m);
                     if (decision.target === 'pty' && decision.bytes != null) {
                         // Submit-fix (2026-06-01): Claude Code's TUI treats a burst of
@@ -457,7 +485,7 @@ async function loadWsShim() {
         throw new Error('`ws` is unavailable. It ships as an optional dependency of @sickr/cli; if it failed to install, try: `npm install -g ws`.');
     }
 }
-function pumpNewLines(ws, offsets) {
+function pumpNewLines(ws, offsets, identity) {
     const dir = runsDir();
     if (!existsSync(dir))
         return;
@@ -482,6 +510,12 @@ function pumpNewLines(ws, offsets) {
             for (const fragment of splitJsonObjects(line)) {
                 try {
                     const event = JSON.parse(fragment);
+                    if (event.runner && event.runner !== identity.runner)
+                        continue;
+                    if (!event.runner && event.agent && normTarget(event.agent) !== normTarget(identity.agent))
+                        continue;
+                    if (event.session)
+                        identity.sessions.add(event.session);
                     ws.send(JSON.stringify({ kind: 'event', event }));
                 }
                 catch { /* skip malformed */ }

package/package.json

@@ -1,18 +1,27 @@
 {
   "name": "@sickr/cli",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "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",