@sickr/cli 0.9.10 → 0.9.11

package/dist/cli.js

@@ -5,7 +5,7 @@ import { homedir, userInfo } from 'node:os';
 import { join, dirname } from 'node:path';
 import { spawn, spawnSync, execFileSync } from 'node:child_process';
 import { appendEvent, loadRun, runsDir, latestRunId } from './recorder.js';
-import { mergeHooks, removeHooks } from './hookConfig.js';
+import { removeHooks, mergeHooksForEvents, removeHooksForEvents } from './hookConfig.js';
 import { renderRunHtml, renderCombinedHtml } from './render.js';
 import { buildSharePayload, buildCombinedPayload, publish, PublishError } from './share.js';
 import { AUTH_ENDPOINT, readCredentials, writeCredentials, clearCredentials, startDevice, pollDevice, sleep } from './auth.js';
@@ -69,8 +69,8 @@ function providerFromFlags(args) {
         return 'codex';
     if (args.includes('--gemini'))
         return 'gemini';
-    if (args.includes('--cursor'))
-        return 'cursor';
+    if (args.includes('--ollama'))
+        return 'ollama';
     if (args.includes('--local'))
         return 'local';
     return 'claude';
@@ -113,7 +113,7 @@ RUN ($12) - remote control from the browser.
                         sickr run claude
                         sickr run codex
                         sickr run gemini
-                        sickr run cursor-agent
+                        sickr run ollama --model llama3.2
                         sickr run <bin>
                       Flags: --mode auto (default) | --mode interactive
 
@@ -129,9 +129,9 @@ 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.
 
-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 one manual /hooks trust approval
+per stable hook command. Gemini uses its native hook events. Ollama is
+the supported local LLM runtime; configure the model on workflow.sickr.ai.
 
 https://sickr.ai
 `;
@@ -172,9 +172,13 @@ export function handleRecord(input, provider = 'claude') {
     try {
         const cc = JSON.parse(input);
         appendEvent(currentRunId(cc), cc, { human: resolveName(), agent: PROVIDERS[provider].recordLabel });
+        if (provider === 'gemini')
+            process.stdout.write('{}\n');
     }
     catch {
         /* swallow: recording is best-effort and must not disrupt the session */
+        if (provider === 'gemini')
+            process.stdout.write('{}\n');
     }
 }
 export function handleInit(provider, noName = false) {
@@ -189,7 +193,8 @@ export function handleInit(provider, noName = false) {
     // 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.
-    const merged = mergeHooks(removeHooks(settings), command);
+    const events = p.hookEvents ?? ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'Stop'];
+    const merged = mergeHooksForEvents(removeHooksForEvents(settings, events), command, events);
     mkdirSync(dirname(settingsPath), { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n');
     mkdirSync(runsDir(), { recursive: true });
@@ -199,7 +204,7 @@ export function handleInit(provider, noName = false) {
     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 = 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`
+        ? `Next: in ${p.displayName}, trust the SICKR recorder once when prompted${provider === 'codex' ? ' (type `/hooks` in Codex)' : ''},\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` +
@@ -674,12 +679,61 @@ export function handleWhoami() {
     process.stdout.write(`sickr: ${c.login}${c.name ? ` (${c.name})` : ''} · since ${c.login_at}\n`);
 }
 function valueAt(rest, flag) {
+    const eq = rest.find((item) => item.startsWith(`${flag}=`));
+    if (eq)
+        return eq.slice(flag.length + 1) || null;
     const i = rest.indexOf(flag);
     return i >= 0 && rest[i + 1] && !rest[i + 1].startsWith('-') ? rest[i + 1] : null;
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function stringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string') ? value : null;
+}
+function providerFromValue(value) {
+    if (value === 'claude' || value === 'codex' || value === 'gemini' || value === 'ollama' || value === 'local')
+        return value;
+    return null;
+}
+function productModeFromValue(value) {
+    if (value === 'prime_workflow' || value === 'run' || value === 'live' || value === 'replay')
+        return value;
+    if (value === 'workflow' || value === 'prime')
+        return 'prime_workflow';
+    return null;
+}
+export function configuredRunInvocationFromStatus(status) {
+    const root = isRecord(status) ? status : {};
+    const agent = isRecord(root.agent) ? root.agent : {};
+    const runtime = isRecord(agent.runtime_config) ? agent.runtime_config
+        : isRecord(agent.run_config) ? agent.run_config
+            : isRecord(root.runtime_config) ? root.runtime_config
+                : {};
+    const provider = providerFromValue(runtime.provider) ?? providerFromValue(agent.provider) ?? 'claude';
+    const productMode = productModeFromValue(runtime.product_mode) ?? productModeFromValue(runtime.mode) ?? productModeFromValue(agent.product_mode) ?? productModeFromValue(agent.mode) ?? 'run';
+    const command = typeof runtime.command === 'string' ? runtime.command
+        : typeof agent.command === 'string' ? agent.command
+            : PROVIDERS[provider].defaultCommand;
+    const configuredArgs = stringArray(runtime.args) ?? stringArray(agent.args) ?? [];
+    const model = typeof runtime.model === 'string' ? runtime.model
+        : typeof agent.model === 'string' ? agent.model
+            : null;
+    const agentArgs = (provider === 'ollama' || provider === 'local') && model && configuredArgs.length === 0
+        ? ['--model', model]
+        : configuredArgs;
+    const mode = runtime.pty_mode === 'interactive' || runtime.run_mode === 'interactive' || runtime.mode === 'interactive' || agent.pty_mode === 'interactive' ? 'interactive' : 'auto';
+    return { agent: command, agentArgs, mode, productMode };
+}
+export async function resolveConfiguredRun(agentId, credentials = readAgentCredentials()) {
+    if (!credentials) {
+        throw new Error('agent is not connected. Run `sickr prime connect --agent-id <id>` first.');
+    }
+    if (credentials.agent_id !== agentId) {
+        throw new Error(`local machine is connected as ${credentials.agent_id}, not ${agentId}. Run \`sickr prime connect --agent-id ${agentId}\` first.`);
+    }
+    return configuredRunInvocationFromStatus(await fetchAgentStatus(credentials));
+}
 function agentContextLabel(context) {
     const root = isRecord(context) ? context : {};
     const agent = isRecord(root.agent) ? root.agent : {};
@@ -870,7 +924,7 @@ async function handleReplay(rest) {
             handleInit('codex', noName);
             return;
         }
-        if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'cursor' || agent === 'local') {
+        if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'ollama' || agent === 'local') {
             handleInit(agent, noName);
             return;
         }
@@ -895,12 +949,12 @@ async function handleReplay(rest) {
             handleOpenCombined(sel);
             return;
         }
-        const openProvider = replayRest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(replayRest) : undefined;
+        const openProvider = replayRest.some((a) => ['--codex', '--claude', '--gemini', '--ollama', '--local'].includes(a)) ? providerFromFlags(replayRest) : undefined;
         handleOpen(replayRest.find((a) => !a.startsWith('-')), openProvider);
         return;
     }
     if (sub === 'list') {
-        const listProvider = replayRest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(replayRest) : undefined;
+        const listProvider = replayRest.some((a) => ['--codex', '--claude', '--gemini', '--ollama', '--local'].includes(a)) ? providerFromFlags(replayRest) : undefined;
         handleList(listProvider);
         return;
     }
@@ -996,6 +1050,56 @@ async function handlePrime(rest) {
     }
     runPrime(rest.length ? rest : ['status']);
 }
+async function handleStart(rest) {
+    const agentId = valueAt(rest, '--agent-id') ?? rest.find((arg) => !arg.startsWith('-')) ?? null;
+    if (!agentId) {
+        await handlePrime(['start', ...rest]);
+        return;
+    }
+    let configured;
+    try {
+        configured = await resolveConfiguredRun(agentId);
+    }
+    catch (e) {
+        process.stderr.write(`sickr: ${e.message}\n`);
+        process.exit(2);
+        return;
+    }
+    if (configured.productMode === 'prime_workflow') {
+        await handlePrime(['start', ...rest]);
+        return;
+    }
+    if (configured.productMode === 'live') {
+        const { startLive } = await import('./live.js');
+        if (!(await requireReplayPro('sickr start'))) {
+            process.exit(3);
+            return;
+        }
+        await startLive({ verbose: rest.includes('--verbose') || rest.includes('-v'), background: rest.includes('--background') });
+        return;
+    }
+    if (configured.productMode === 'replay') {
+        await handleReplay([]);
+        return;
+    }
+    if (!(await requireReplayPro('sickr start'))) {
+        process.exit(3);
+        return;
+    }
+    const { startRun } = await import('./run.js');
+    try {
+        await startRun({
+            agent: configured.agent,
+            agentArgs: configured.agentArgs,
+            verbose: rest.includes('--verbose') || rest.includes('-v'),
+            mode: configured.mode,
+        });
+    }
+    catch (e) {
+        process.stderr.write(`sickr: ${e.message}\n`);
+        process.exit(5);
+    }
+}
 export async function readStreamWithIdle(input, idleMs = 250, emptyMs = 1500) {
     const chunks = [];
     const iterator = input[Symbol.asyncIterator]();
@@ -1052,7 +1156,7 @@ async function main() {
                 handleInit('codex', noName);
                 return;
             }
-            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'cursor' || agent === 'local') {
+            if (agent === 'claude' || agent === 'codex' || agent === 'gemini' || agent === 'ollama' || agent === 'local') {
                 handleInit(agent, noName);
                 return;
             }
@@ -1066,12 +1170,12 @@ async function main() {
                 handleOpenCombined(sel);
                 return;
             }
-            const openProvider = rest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(rest) : undefined;
+            const openProvider = rest.some((a) => ['--codex', '--claude', '--gemini', '--ollama', '--local'].includes(a)) ? providerFromFlags(rest) : undefined;
             handleOpen(rest.find((a) => !a.startsWith('-')), openProvider);
             return;
         }
         case 'list': {
-            const listProvider = rest.some((a) => ['--codex', '--claude', '--gemini', '--cursor', '--local'].includes(a)) ? providerFromFlags(rest) : undefined;
+            const listProvider = rest.some((a) => ['--codex', '--claude', '--gemini', '--ollama', '--local'].includes(a)) ? providerFromFlags(rest) : undefined;
             handleList(listProvider);
             return;
         }
@@ -1100,7 +1204,7 @@ async function main() {
             await handlePrime(rest);
             return;
         case 'start':
-            await handlePrime(['start', ...rest]);
+            await handleStart(rest);
             return;
         case 'status':
             await handlePrime(['status', ...rest]);
@@ -1156,6 +1260,13 @@ async function main() {
             const filtered = [];
             let mode = 'auto';
             for (let i = 0; i < rest.length; i++) {
+                if (rest[i] === '--agent-id' && rest[i + 1]) {
+                    i++;
+                    continue;
+                }
+                if (rest[i].startsWith('--agent-id=')) {
+                    continue;
+                }
                 if (rest[i] === '--mode' && rest[i + 1]) {
                     const v = rest[i + 1];
                     if (v !== 'auto' && v !== 'interactive') {
@@ -1181,15 +1292,30 @@ async function main() {
             }
             const positional = filtered.filter((a) => !a.startsWith('-'));
             const flags = filtered.filter((a) => a.startsWith('-'));
-            const agent = positional[0];
+            const configuredAgentId = valueAt(rest, '--agent-id');
+            let agent = positional[0];
+            let configuredArgs = null;
+            if (!agent && configuredAgentId) {
+                try {
+                    const configured = await resolveConfiguredRun(configuredAgentId);
+                    agent = configured.agent;
+                    configuredArgs = configured.agentArgs;
+                    mode = configured.mode;
+                }
+                catch (e) {
+                    process.stderr.write(`sickr: ${e.message}\n`);
+                    process.exit(2);
+                    return;
+                }
+            }
             if (!agent) {
-                process.stderr.write('sickr: usage — `sickr run <agent> [--mode auto|interactive] [args...]` (agent: claude | codex | <bin name>)\n');
+                process.stderr.write('sickr: usage — `sickr run <agent> [--mode auto|interactive] [args...]` or `sickr run --agent-id <id>`\n');
                 process.exit(1);
                 return;
             }
             // Pass through every non-sickr flag plus positional tail to the agent.
-            const passthroughFlags = flags.filter((f) => f !== '--verbose' && f !== '-v');
-            const agentArgs = [...passthroughFlags, ...positional.slice(1)];
+            const passthroughFlags = flags.filter((f) => f !== '--verbose' && f !== '-v' && f !== '--agent-id');
+            const agentArgs = configuredArgs ?? [...passthroughFlags, ...positional.slice(1)];
             const verbose = flags.includes('--verbose') || flags.includes('-v');
             if (!(await requireReplayPro('sickr run'))) {
                 process.exit(3);

package/dist/hookConfig.js

@@ -1,6 +1,6 @@
 // PreToolUse (not PostToolUse) captures each tool action once — hooking both
 // would record every tool twice. Stop carries the assistant's final response.
-const EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'Stop'];
+const DEFAULT_EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'Stop'];
 const TAG = 'npx @sickr/cli record';
 const LEGACY_TAGS = ['@sickr/replay record', 'npx sickr record'];
 /**
@@ -8,31 +8,34 @@ const LEGACY_TAGS = ['@sickr/replay record', 'npx sickr record'];
  * Idempotent — re-running never duplicates the SICKR hook. Preserves any
  * existing unrelated hooks.
  */
-export function mergeHooks(settings, recordCommand) {
+export function mergeHooksForEvents(settings, recordCommand, events = DEFAULT_EVENTS) {
     const next = { ...(settings ?? {}) };
     next.hooks = { ...(next.hooks ?? {}) };
     const command = /\brecord\b/.test(recordCommand) ? recordCommand : `${recordCommand} record`;
-    for (const ev of EVENTS) {
+    for (const ev of events) {
         const groups = Array.isArray(next.hooks[ev]) ? [...next.hooks[ev]] : [];
         const serialized = JSON.stringify(groups);
         const present = serialized.includes(TAG) || LEGACY_TAGS.some((tag) => serialized.includes(tag));
         if (!present)
-            groups.push({ hooks: [{ type: 'command', command }] });
+            groups.push({ hooks: [{ type: 'command', command, name: 'SICKR recorder', timeout: 10000 }] });
         next.hooks[ev] = groups;
     }
     return next;
 }
+export function mergeHooks(settings, recordCommand) {
+    return mergeHooksForEvents(settings, recordCommand, DEFAULT_EVENTS);
+}
 /**
  * Remove the SICKR recording hooks from a Claude Code settings object — the
  * inverse of mergeHooks. Unrelated hooks are preserved; an event left with no
  * hooks is dropped so settings.json stays clean.
  */
-export function removeHooks(settings) {
+export function removeHooksForEvents(settings, events = DEFAULT_EVENTS) {
     const next = { ...(settings ?? {}) };
     if (!next.hooks)
         return next;
     const hooks = { ...next.hooks };
-    for (const ev of EVENTS) {
+    for (const ev of events) {
         const groups = Array.isArray(hooks[ev]) ? hooks[ev] : undefined;
         if (!groups)
             continue;
@@ -48,3 +51,6 @@ export function removeHooks(settings) {
     next.hooks = hooks;
     return next;
 }
+export function removeHooks(settings) {
+    return removeHooksForEvents(settings, DEFAULT_EVENTS);
+}

package/dist/providers.js

@@ -10,6 +10,7 @@ export const PROVIDERS = {
         supportsPtyControl: true,
         supportsStructuredStream: false,
         settingsPath: () => join(process.cwd(), '.claude', 'settings.json'),
+        hookEvents: ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'Stop'],
         notes: 'Hooks are installed into .claude/settings.json and Claude reads them without an extra trust command.',
     },
     codex: {
@@ -23,6 +24,7 @@ export const PROVIDERS = {
         supportsStructuredStream: false,
         settingsPath: () => join(process.cwd(), '.codex', 'hooks.json'),
         recordFlag: '--codex',
+        hookEvents: ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'Stop'],
         notes: 'Codex requires the user to type /hooks once and trust the SICKR recorder.',
     },
     gemini: {
@@ -36,29 +38,30 @@ export const PROVIDERS = {
         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.',
+        hookEvents: ['SessionStart', 'BeforeAgent', 'BeforeTool', 'AfterAgent', 'SessionEnd'],
+        notes: 'Gemini CLI hooks use BeforeAgent/BeforeTool/AfterAgent events and require JSON-safe hook output.',
     },
-    cursor: {
-        provider: 'cursor',
-        displayName: 'Cursor CLI',
-        recordLabel: 'Cursor',
-        defaultCommand: 'cursor-agent',
+    ollama: {
+        provider: 'ollama',
+        displayName: 'Ollama',
+        recordLabel: 'Ollama',
+        defaultCommand: 'ollama',
         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.',
+        supportsStructuredStream: false,
+        notes: 'Ollama is the first supported local runtime. Configure the model in workflow.sickr.ai and run through the PTY wrapper.',
     },
     local: {
         provider: 'local',
         displayName: 'Local LLM',
         recordLabel: 'Local',
-        defaultCommand: 'sickr-local-agent',
+        defaultCommand: 'ollama',
         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.',
+        notes: 'Custom local runtimes use the configured command from workflow.sickr.ai. Ollama is the supported default.',
     },
 };
 export function providerForAgent(agent) {
@@ -70,9 +73,9 @@ export function providerForAgent(agent) {
         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')
+    if (base === 'ollama')
+        return 'ollama';
+    if (base === 'vllm' || base === 'llama.cpp' || base === 'llama-server' || base === 'sickr-local-agent')
         return 'local';
     return null;
 }

package/dist/recorder.js

@@ -99,14 +99,23 @@ export function mapEvent(cc, now = new Date(), ctx = {}) {
         case 'SessionStart':
             return { kind: 'start', label: 'Session', detail: redact(String(cc.cwd ?? '')), ...base };
         case 'UserPromptSubmit':
+        case 'BeforeAgent':
             return { kind: 'prompt', label: (ctx.human || 'Human').slice(0, 40), detail: redact(String(cc.prompt ?? '')).slice(0, 400), ...base };
         case 'Stop': {
             // Codex hands us the reply directly; Claude Code we read from the transcript.
             const text = String(cc.last_assistant_message ?? '') || (cc.transcript_path ? extractLastAssistantText(String(cc.transcript_path)) : '');
             return { kind: 'response', label: (ctx.agent || 'Agent').slice(0, 40), detail: redact(text).slice(0, 2000), ...base };
         }
+        case 'AfterAgent': {
+            const text = String(cc.prompt_response ?? cc.last_assistant_message ?? '');
+            return { kind: 'response', label: (ctx.agent || 'Agent').slice(0, 40), detail: redact(text).slice(0, 2000), ...base };
+        }
+        case 'SessionEnd':
+            return { kind: 'stop', label: 'Session', detail: redact(String(cc.reason ?? 'ended')), ...base };
         case 'PreToolUse':
-        case 'PostToolUse': {
+        case 'BeforeTool':
+        case 'PostToolUse':
+        case 'AfterTool': {
             const tool = String(cc.tool_name ?? 'tool');
             const input = (cc.tool_input ?? {});
             let raw;

package/dist/run.js

@@ -28,7 +28,7 @@ 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 { mergeHooksForEvents, removeHooksForEvents } from './hookConfig.js';
 import { LIVE_BASE, decodeWsPayload, splitJsonObjects } from './live.js';
 import { PROVIDERS, providerForAgent, recordCommandFor } from './providers.js';
 /** Resolve the agent binary path. Precedence:
@@ -237,7 +237,8 @@ export function ensureRecordingHooks(agent) {
     // load (tiny boot perf + lets tests run without the module).
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const command = recordCommandFor(provider);
-    const merged = mergeHooks(removeHooks(existing), command);
+    const events = adapter.hookEvents ?? ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'Stop'];
+    const merged = mergeHooksForEvents(removeHooksForEvents(existing, events), command, events);
     mkdirSync(join(settingsPath, '..'), { recursive: true });
     writeFileSync(settingsPath, JSON.stringify(merged, null, 2) + '\n');
     mkdirSync(runsDir(), { recursive: true });
@@ -288,6 +289,26 @@ export function autoModeArgsFor(agent, existingArgs) {
     // Unknown agent — no opinion. Operator should pass their own flags.
     return [];
 }
+export function providerArgsFor(agent, existingArgs) {
+    const provider = providerForAgent(agent);
+    if (provider !== 'ollama')
+        return existingArgs;
+    if (existingArgs[0] === 'run' || existingArgs[0] === 'serve' || existingArgs[0] === 'pull')
+        return existingArgs;
+    const modelFlag = existingArgs.findIndex((arg) => arg === '--model');
+    if (modelFlag >= 0 && existingArgs[modelFlag + 1]) {
+        return ['run', existingArgs[modelFlag + 1], ...existingArgs.filter((_, index) => index !== modelFlag && index !== modelFlag + 1)];
+    }
+    const modelEq = existingArgs.find((arg) => arg.startsWith('--model='));
+    if (modelEq) {
+        const model = modelEq.slice('--model='.length);
+        return ['run', model, ...existingArgs.filter((arg) => arg !== modelEq)];
+    }
+    const model = process.env.SICKR_OLLAMA_MODEL;
+    if (model)
+        return ['run', model, ...existingArgs];
+    return existingArgs;
+}
 export async function startRun(opts) {
     const creds = readCredentials();
     if (!creds) {
@@ -319,7 +340,7 @@ export async function startRun(opts) {
     // operator can't see. --mode interactive disables the injection.
     const mode = opts.mode ?? 'auto';
     const injected = mode === 'auto' ? autoModeArgsFor(opts.agent, opts.agentArgs) : [];
-    const effectiveArgs = [...injected, ...opts.agentArgs];
+    const effectiveArgs = providerArgsFor(opts.agent, [...injected, ...opts.agentArgs]);
     process.stdout.write(`sickr: wrapping ${agentBin} in PTY. Watch + steer at: https://sickr.ai/r/${urlid}\n`);
     if (mode === 'auto' && injected.length > 0) {
         process.stdout.write(`       mode=auto — injected ${injected.join(' ')} (use --mode interactive to disable)\n`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sickr/cli",
-  "version": "0.9.10",
+  "version": "0.9.11",
   "type": "module",
   "description": "npx @sickr/cli - replay, live look, and workflow orchestration for AI coding agents.",
   "bin": {