@polderlabs/bizar 10.5.0 → 10.7.0

package/bizar-dash/tests/task-splitter.test.mjs

@@ -0,0 +1,268 @@
+/**
+ * tests/task-splitter.test.mjs
+ *
+ * Self-check for task-splitter.mjs (G-autoloop Phase 3).
+ */
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+
+const {
+  estimateSize,
+  avgHistoricalMinutes,
+  shouldSplit,
+  planSplit,
+  acceptSplit,
+  rollupProgress,
+  goalAwarePriority,
+} = await import('../src/server/task-splitter.mjs');
+
+// ---- estimateSize ---------------------------------------------------------
+
+test('estimateSize: tiny tasks → S', () => {
+  const size = estimateSize({ title: 'fix typo', description: '' });
+  assert.equal(size, 'S');
+});
+
+test('estimateSize: medium tasks with description → M or L', () => {
+  const size = estimateSize({
+    title: 'Add a /metrics Prometheus endpoint to the dash server',
+    description: 'Wire app.get("/metrics") using prom-client; expose httpRequestsTotal as gauge and counter, label by route+status; gate on auth.',
+  });
+  assert.ok(['M', 'L'].includes(size), `expected M or L, got ${size}`);
+});
+
+test('estimateSize: linked goal+kr pushes to L or XL', () => {
+  const size = estimateSize({
+    title: 'Refactor agent routing',
+    metadata: { goalId: 'G-1', krId: 'KR-1' },
+    description: 'medium',
+  });
+  assert.ok(['L', 'XL'].includes(size), `got ${size}`);
+});
+
+test('estimateSize: long description pushes to XL', () => {
+  const longDesc = 'word '.repeat(800).trim();
+  const size = estimateSize({
+    title: 'huge task',
+    description: longDesc,
+  });
+  assert.equal(size, 'XL');
+});
+
+test('estimateSize: history of > 6h avg pushes up', () => {
+  const history = [
+    { title: 'Huge task redesign dashboard', timeSpent: 400 },
+    { title: 'Huge task refactor navigation', timeSpent: 500 },
+    { title: 'Huge task wire up', timeSpent: 450 },
+  ];
+  const size = estimateSize({ title: 'Huge task integrate', description: '' }, history);
+  assert.ok(['L', 'XL'].includes(size), `got ${size}`);
+});
+
+test('estimateSize: history < 2 items is ignored', () => {
+  const history = [{ title: 'Huge task first', timeSpent: 600 }];
+  const size = estimateSize({ title: 'tiny', description: '' }, history);
+  assert.equal(size, 'S');
+});
+
+test('estimateSize: bad input → M', () => {
+  assert.equal(estimateSize(null), 'M');
+  assert.equal(estimateSize(undefined), 'M');
+  assert.equal(estimateSize('not a task'), 'M');
+});
+
+// ---- avgHistoricalMinutes -------------------------------------------------
+
+test('avgHistoricalMinutes: matches on overlapping title words', () => {
+  const history = [
+    { title: 'Refactor the sidebar navigation', timeSpent: 30 },
+    { title: 'Refactor the dashboard navigation', timeSpent: 90 },
+    { title: 'Refresh everything else', timeSpent: 60 },
+  ];
+  const mins = avgHistoricalMinutes({ title: 'Refactor the sidebar navigation' }, history);
+  // overlap≥2 with the candidate; first two share "Refactor" + "navigation".
+  assert.equal(mins, (30 + 90) / 2);
+});
+
+test('avgHistoricalMinutes: ignores zero/negative timeSpent rows', () => {
+  const history = [
+    { title: 'wire up routes', timeSpent: 30 },
+    { title: 'wire up nav', timeSpent: 0 },
+    { title: 'wire up tasks', timeSpent: -5 },
+  ];
+  // Title words: "wire", "up", "routes" / "nav" / "tasks"; "up" is short
+  // and dropped (>3 filter). Only "wire" overlap → match by ≥1? No, we
+  // require ≥2. So only "wire up routes" should match (shares "wire",
+  // "routes").
+  const mins = avgHistoricalMinutes({ title: 'wire up routes' }, history);
+  assert.equal(mins, 30);
+});
+
+test('avgHistoricalMinutes: short history is unreliable', () => {
+  const history = [{ title: 'Refactor the dashboard', timeSpent: 600 }];
+  assert.equal(avgHistoricalMinutes({ title: 'Refactor the dashboard' }, history), 0);
+});
+
+test('avgHistoricalMinutes: no word overlap → 0', () => {
+  const history = [
+    { title: 'completely unrelated task alpha beta', timeSpent: 600 },
+    { title: 'completely unrelated task gamma delta', timeSpent: 600 },
+  ];
+  assert.equal(avgHistoricalMinutes({ title: 'tiny change' }, history), 0);
+});
+
+// ---- shouldSplit ----------------------------------------------------------
+
+test('shouldSplit: implicit L+ → true', () => {
+  const task = {
+    title: 'Refactor the dashboard and rewrite every component',
+    description: 'huge'.repeat(200),
+    metadata: { goalId: 'G-1', krId: 'KR-1' },
+  };
+  assert.equal(shouldSplit(task), true);
+});
+
+test('shouldSplit: small tasks → false', () => {
+  assert.equal(shouldSplit({ title: 'fix typo' }), false);
+});
+
+test('shouldSplit: explicit metadata wins over heuristic', () => {
+  // Small task, but force split via metadata.
+  assert.equal(shouldSplit({ title: 'tiny', metadata: { autoSplit: true } }), true);
+  // Big task, but explicitly forbid splitting.
+  assert.equal(
+    shouldSplit({
+      title: 'huge '.repeat(50).trim(),
+      description: 'big',
+      metadata: { autoSplit: false },
+    }),
+    false,
+  );
+});
+
+// ---- planSplit ------------------------------------------------------------
+
+test('planSplit: requires id, returns prompt + constraints', () => {
+  assert.throws(() => planSplit(null), TypeError);
+  assert.throws(() => planSplit({}), TypeError);
+  const plan = planSplit({
+    id: 'tsk_abc',
+    title: 'wire up autonomous loop',
+    description: 'big change',
+    assignee: 'tyr',
+    metadata: { goalId: 'G-1' },
+  });
+  assert.equal(plan.kind, 'task-decompose');
+  assert.equal(plan.parentTaskId, 'tsk_abc');
+  assert.ok(plan.prompt.includes('wire up autonomous loop'));
+  assert.ok(plan.prompt.includes('Linked goal: G-1'));
+  assert.equal(plan.constraints.min, 2);
+  assert.equal(plan.constraints.max, 5);
+});
+
+// ---- acceptSplit ----------------------------------------------------------
+
+test('acceptSplit: filters out malformed candidates', () => {
+  const candidates = [
+    { title: 'subtask 1', description: 'ok' },
+    null,
+    { title: '' },
+    { title: 'subtask 2' },
+    { title: 42 }, // wrong type
+    { title: 'subtask 3' },
+    { title: 'subtask 4' },
+    { title: 'subtask 5' },
+    { title: 'subtask 6' },
+    'string not object',
+  ];
+  const out = acceptSplit(candidates);
+  assert.equal(out.length, 5); // capped at max=5; we drop empty/numbered/string
+  assert.deepEqual(out.map((o) => o.title), ['subtask 1', 'subtask 2', 'subtask 3', 'subtask 4', 'subtask 5']);
+});
+
+test('acceptSplit: below minimum → empty', () => {
+  const out = acceptSplit([{ title: 'only' }]);
+  assert.equal(out.length, 0);
+});
+
+test('acceptSplit: trims oversize title and description', () => {
+  const longTitle = 'x'.repeat(500);
+  const longDesc = 'y'.repeat(10000);
+  const out = acceptSplit([
+    { title: longTitle, description: longDesc },
+    { title: 'second' },
+  ]);
+  assert.equal(out[0].title.length, 200);
+  assert.equal(out[0].description.length, 4000);
+});
+
+test('acceptSplit: tags default to autosplit, priority defaults to 5', () => {
+  const out = acceptSplit([{ title: 'a' }, { title: 'b', priority: 2, tags: ['foo'] }]);
+  assert.equal(out[0].priority, 5);
+  assert.deepEqual(out[0].tags, ['autosplit']);
+  assert.equal(out[1].priority, 2);
+  assert.deepEqual(out[1].tags, ['foo']);
+});
+
+// ---- rollupProgress -------------------------------------------------------
+
+test('rollupProgress: counts done children', () => {
+  const parent = {
+    subtasks: [
+      { status: 'done' },
+      { status: 'doing' },
+      { status: 'done' },
+      { status: 'queued' },
+    ],
+  };
+  const r = rollupProgress(parent);
+  assert.equal(r.ratio, 0.5);
+  assert.equal(r.allDone, false);
+});
+
+test('rollupProgress: allDone when every child is done', () => {
+  const parent = {
+    subtasks: [{ status: 'done' }, { status: 'done' }],
+  };
+  const r = rollupProgress(parent);
+  assert.equal(r.ratio, 1);
+  assert.equal(r.allDone, true);
+});
+
+test('rollupProgress: no children → zeros', () => {
+  assert.deepEqual(rollupProgress({}), { ratio: 0, allDone: false });
+  assert.deepEqual(rollupProgress(null), { ratio: 0, allDone: false });
+});
+
+// ---- goalAwarePriority ----------------------------------------------------
+
+test('goalAwarePriority: at-risk goal bumps priority', () => {
+  const out = goalAwarePriority({ priority: 4 }, { status: 'at-risk' });
+  assert.equal(out.priority, 3);
+  assert.equal(out.action, 'bump');
+});
+
+test('goalAwarePriority: at-risk clamps at 1', () => {
+  const out = goalAwarePriority({ priority: 1 }, { status: 'at-risk' });
+  assert.equal(out.priority, 1);
+  assert.equal(out.action, 'bump');
+});
+
+test('goalAwarePriority: blocked goal holds priority', () => {
+  const out = goalAwarePriority({ priority: 3 }, { status: 'blocked' });
+  assert.equal(out.priority, 3);
+  assert.equal(out.action, 'none');
+});
+
+test('goalAwarePriority: done goal de-prioritises', () => {
+  const out = goalAwarePriority({ priority: 2 }, { status: 'done' });
+  assert.equal(out.priority, 9);
+  assert.equal(out.action, 'drop');
+});
+
+test('goalAwarePriority: missing goal or task → no change', () => {
+  assert.equal(goalAwarePriority(null, { status: 'at-risk' }).action, 'none');
+  assert.equal(goalAwarePriority({ priority: 3 }, null).action, 'none');
+  assert.equal(goalAwarePriority({ priority: 3 }, { status: 'on-track' }).action, 'none');
+});

package/cli/__tests__/feature-list-bridge.test.mjs

@@ -82,10 +82,10 @@ describe('claim()', () => {
   afterEach(() => { /* tmp cleaned in after() */ });
 
   test('first claim succeeds', () => {
-    const result = br.claim('F-A', { type: 'human', id: 'odin', name: 'Odin' }, 'first-run');
+    const result = br.claim('F-A', { type: 'human', id: 'mike', name: 'Odin' }, 'first-run');
     assert.equal(result.ok, true);
     const f = result.feature;
-    assert.equal(f.claimant.id, 'odin');
+    assert.equal(f.claimant.id, 'mike');
     assert.equal(f.claimStatus, 'claimed');
     assert.ok(f.claimedAt);
     assert.equal(f.claimReason, 'first-run');
@@ -94,9 +94,9 @@ describe('claim()', () => {
   });
 
   test('second claim rejected with ALREADY_CLAIMED', () => {
-    br.claim('F-A', { type: 'human', id: 'odin', name: 'Odin' }, 'first-run');
+    br.claim('F-A', { type: 'human', id: 'mike', name: 'Odin' }, 'first-run');
     assert.throws(
-      () => br.claim('F-A', { type: 'agent', id: 'tyr' }, 'second-run'),
+      () => br.claim('F-A', { type: 'agent', id: 'karen' }, 'second-run'),
       (err) => err instanceof ClaimError && err.code === 'ALREADY_CLAIMED',
     );
   });
@@ -116,10 +116,10 @@ describe('claim()', () => {
   });
 
   test('can re-claim a completed feature', () => {
-    br.claim('F-A', { type: 'human', id: 'odin' }, '');
-    br.transition('F-A', 'completed', { id: 'odin' }, '');
+    br.claim('F-A', { type: 'human', id: 'mike' }, '');
+    br.transition('F-A', 'completed', { id: 'mike' }, '');
     // released -> re-claimable
-    const r2 = br.claim('F-A', { type: 'agent', id: 'tyr' }, 'second life');
+    const r2 = br.claim('F-A', { type: 'agent', id: 'karen' }, 'second life');
     assert.equal(r2.ok, true);
   });
 });
@@ -135,8 +135,8 @@ describe('release()', () => {
   });
 
   test('release after claim sets status to unclaimed', () => {
-    br.claim('F-X', { type: 'human', id: 'odin' }, '');
-    const result = br.release('F-X', { id: 'odin' }, 'done');
+    br.claim('F-X', { type: 'human', id: 'mike' }, '');
+    const result = br.release('F-X', { id: 'mike' }, 'done');
     assert.equal(result.ok, true);
     assert.equal(result.feature.claimStatus, 'unclaimed');
     assert.equal(result.feature.claimant, null);
@@ -145,15 +145,15 @@ describe('release()', () => {
 
   test('release without claim errors with NOT_CLAIMED', () => {
     assert.throws(
-      () => br.release('F-X', { id: 'odin' }, ''),
+      () => br.release('F-X', { id: 'mike' }, ''),
       (err) => err instanceof ClaimError && err.code === 'NOT_CLAIMED',
     );
   });
 
   test('release with wrong claimant errors with WRONG_CLAIMANT', () => {
-    br.claim('F-X', { type: 'human', id: 'odin' }, '');
+    br.claim('F-X', { type: 'human', id: 'mike' }, '');
     assert.throws(
-      () => br.release('F-X', { id: 'tyr' }, ''),
+      () => br.release('F-X', { id: 'karen' }, ''),
       (err) => err instanceof ClaimError && err.code === 'WRONG_CLAIMANT',
     );
   });
@@ -170,15 +170,15 @@ describe('handoff()', () => {
   });
 
   test('handoff moves claimant', () => {
-    br.claim('F-H', { type: 'human', id: 'odin' }, '');
+    br.claim('F-H', { type: 'human', id: 'mike' }, '');
     const result = br.handoff(
       'F-H',
-      { type: 'human', id: 'odin' },
-      { type: 'agent', id: 'tyr', name: 'Tyr' },
+      { type: 'human', id: 'mike' },
+      { type: 'agent', id: 'karen', name: 'Tyr' },
       'context finished',
     );
     assert.equal(result.ok, true);
-    assert.equal(result.feature.claimant.id, 'tyr');
+    assert.equal(result.feature.claimant.id, 'karen');
     assert.equal(result.feature.claimStatus, 'claimed');
     // history: claim + handoff-initiated + handoff-accepted
     const events = result.feature.claimHistory.map((e) => e.event);
@@ -189,8 +189,8 @@ describe('handoff()', () => {
     assert.throws(
       () => br.handoff(
         'F-H',
-        { type: 'human', id: 'odin' },
-        { type: 'agent', id: 'tyr' },
+        { type: 'human', id: 'mike' },
+        { type: 'agent', id: 'karen' },
         '',
       ),
       (err) => err instanceof ClaimError && err.code === 'NOT_CLAIMED',
@@ -209,17 +209,17 @@ describe('steal()', () => {
   });
 
   test('steal moves the claim', () => {
-    br.claim('F-S', { type: 'human', id: 'odin' }, '');
+    br.claim('F-S', { type: 'human', id: 'mike' }, '');
     for (const reason of STEAL_REASONS) {
       // Steal a fresh feature for each reason to avoid ALREADY_CLAIMED.
       const f = minimalFeature(`F-S-${reason}`);
       const fFile = writeFixture(tmp, `s-${reason}.json`, [f]);
       const subBridge = bridgeFactory(fFile);
       subBridge.claim(`F-S-${reason}`, { type: 'agent', id: 'previous' }, '');
-      const result = subBridge.steal(`F-S-${reason}`, { type: 'agent', id: 'tyr' }, reason);
+      const result = subBridge.steal(`F-S-${reason}`, { type: 'agent', id: 'karen' }, reason);
       assert.equal(result.ok, true);
       assert.equal(result.previousClaimant.id, 'previous');
-      assert.equal(result.feature.claimant.id, 'tyr');
+      assert.equal(result.feature.claimant.id, 'karen');
       assert.equal(result.stealReason, reason);
       assert.ok(
         result.feature.claimHistory.some((e) => e.event === 'steal' && e.reason === reason),
@@ -228,9 +228,9 @@ describe('steal()', () => {
   });
 
   test('steal rejects unknown reason', () => {
-    br.claim('F-S', { type: 'human', id: 'odin' }, '');
+    br.claim('F-S', { type: 'human', id: 'mike' }, '');
     assert.throws(
-      () => br.steal('F-S', { type: 'agent', id: 'tyr' }, 'bogus-reason'),
+      () => br.steal('F-S', { type: 'agent', id: 'karen' }, 'bogus-reason'),
       (err) => err instanceof ClaimError && err.code === 'UNKNOWN_STEAL_REASON',
     );
   });
@@ -247,30 +247,30 @@ describe('transition()', () => {
   });
 
   test('claim → active → paused → active → completed', () => {
-    br.claim('F-T', { type: 'human', id: 'odin' }, '');
-    br.transition('F-T', 'active', { id: 'odin' }, '');
+    br.claim('F-T', { type: 'human', id: 'mike' }, '');
+    br.transition('F-T', 'active', { id: 'mike' }, '');
     assert.equal(br.get('F-T').claimStatus, 'active');
-    br.transition('F-T', 'paused', { id: 'odin' }, 'lunch');
+    br.transition('F-T', 'paused', { id: 'mike' }, 'lunch');
     assert.equal(br.get('F-T').claimStatus, 'paused');
-    br.transition('F-T', 'active', { id: 'odin' }, '');
+    br.transition('F-T', 'active', { id: 'mike' }, '');
     assert.equal(br.get('F-T').claimStatus, 'active');
-    br.transition('F-T', 'completed', { id: 'odin' }, '');
+    br.transition('F-T', 'completed', { id: 'mike' }, '');
     assert.equal(br.get('F-T').claimStatus, 'completed');
   });
 
   test('illegal transition rejected', () => {
-    br.claim('F-T', { type: 'human', id: 'odin' }, '');
+    br.claim('F-T', { type: 'human', id: 'mike' }, '');
     // claimed → blocked is NOT in ALLOWED_TRANSITIONS['claimed']
     assert.throws(
-      () => br.transition('F-T', 'blocked', { id: 'odin' }, ''),
+      () => br.transition('F-T', 'blocked', { id: 'mike' }, ''),
       (err) => err instanceof ClaimError && err.code === 'BAD_TRANSITION',
     );
   });
 
   test('unknown status rejected', () => {
-    br.claim('F-T', { type: 'human', id: 'odin' }, '');
+    br.claim('F-T', { type: 'human', id: 'mike' }, '');
     assert.throws(
-      () => br.transition('F-T', 'bogus', { id: 'odin' }, ''),
+      () => br.transition('F-T', 'bogus', { id: 'mike' }, ''),
       (err) => err instanceof ClaimError && err.code === 'UNKNOWN_STATUS',
     );
   });
@@ -292,12 +292,12 @@ describe('list()', () => {
   });
 
   test('claims 2, handoffs 1, steals 1 — list filters', () => {
-    br.claim('F-1', { type: 'human', id: 'odin' }, '');
-    br.claim('F-2', { type: 'agent', id: 'tyr' }, '');
-    br.claim('F-3', { type: 'human', id: 'odin' }, '');
-    br.handoff('F-3', { type: 'human', id: 'odin' }, { type: 'agent', id: 'tyr' }, '');
-    br.claim('F-4', { type: 'human', id: 'mimir' }, '');
-    br.steal('F-4', { type: 'agent', id: 'tyr' }, 'voluntary');
+    br.claim('F-1', { type: 'human', id: 'mike' }, '');
+    br.claim('F-2', { type: 'agent', id: 'karen' }, '');
+    br.claim('F-3', { type: 'human', id: 'mike' }, '');
+    br.handoff('F-3', { type: 'human', id: 'mike' }, { type: 'agent', id: 'karen' }, '');
+    br.claim('F-4', { type: 'human', id: 'greg' }, '');
+    br.steal('F-4', { type: 'agent', id: 'karen' }, 'voluntary');
 
     const all = br.list();
     assert.equal(all.length, 4);
@@ -310,8 +310,8 @@ describe('list()', () => {
     assert.ok(humanIds.includes('F-1'), 'F-1 stayed human');
     assert.ok(!humanIds.includes('F-4'), 'F-4 is now an agent claim');
 
-    const byOdin = br.list({ claimantId: 'odin' });
-    assert.equal(byOdin.length, 1, 'only F-1 still belongs to odin');
+    const byOdin = br.list({ claimantId: 'mike' });
+    assert.equal(byOdin.length, 1, 'only F-1 still belongs to mike');
     assert.equal(byOdin[0].id, 'F-1');
   });
 
@@ -327,9 +327,9 @@ describe('persistence', () => {
   test('bridges are independent — each gets its own file', () => {
     const file = writeFixture(tmp, `p-${Math.random().toString(36).slice(2, 6)}.json`, [minimalFeature('F-P')]);
     const a = bridgeFactory(file);
-    a.claim('F-P', { type: 'human', id: 'odin' }, '');
+    a.claim('F-P', { type: 'human', id: 'mike' }, '');
     const b = bridgeFactory(file);
-    assert.equal(b.get('F-P').claimant.id, 'odin');
+    assert.equal(b.get('F-P').claimant.id, 'mike');
     assert.equal(b.get('F-P').claimStatus, 'claimed');
   });
 

package/cli/agent-browser-up.sh

@@ -1,33 +1,33 @@
 #!/usr/bin/env bash
 #
-# cli/agent-browser-up.sh — install/launch agent-browser for Cline.
+# cli/kevin-up.sh — install/launch kevin for Cline.
 # v6.0.0 — Replaces browser-harness (Python, v3.20.7-v5.6.0) with
-# agent-browser (native Rust CLI from vercel-labs, ~38K★).
+# kevin (native Rust CLI from vercel-labs, ~38K★).
 #
-# agent-browser is a thin CLI wrapper around Chrome for Testing that
+# kevin is a thin CLI wrapper around Chrome for Testing that
 # gives agents access to:
 #   - 100+ typed CLI commands (open, snapshot, click, fill, screenshot, …)
-#   - Native MCP stdio server (`agent-browser mcp`)
+#   - Native MCP stdio server (`kevin mcp`)
 #   - Self-healing snapshot-based element detection
 #   - Plugins (vault, recorder, …)
 #   - Vercel AI SDK + AI Gateway integration (natural-language `chat`)
 #
-# Install:  npm install -g agent-browser
-#           agent-browser install        # downloads Chrome for Testing
+# Install:  npm install -g kevin
+#           kevin install        # downloads Chrome for Testing
 #
 # This script ensures the daemon is up before Bizar agents try to
 # drive the browser. Idempotent: re-running is a no-op if already up.
 #
 # Usage:
-#   cli/agent-browser-up.sh                 # start if not running
-#   cli/agent-browser-up.sh status          # print status
-#   cli/agent-browser-up.sh stop            # kill daemon
-#   cli/agent-browser-up.sh restart         # stop + start
-#   cli/agent-browser-up.sh install         # install + bootstrap
-#   cli/agent-browser-up.sh doctor          # run agent-browser doctor
+#   cli/kevin-up.sh                 # start if not running
+#   cli/kevin-up.sh status          # print status
+#   cli/kevin-up.sh stop            # kill daemon
+#   cli/kevin-up.sh restart         # stop + start
+#   cli/kevin-up.sh install         # install + bootstrap
+#   cli/kevin-up.sh doctor          # run kevin doctor
 #
 # Environment overrides:
-#   AB_PROFILE      — user-data-dir (default: ~/.agent-browser/profile)
+#   AB_PROFILE      — user-data-dir (default: ~/.kevin/profile)
 #   AGENT_BROWSER_API_KEY — for natural-language chat
 #
 # Exit codes:
@@ -36,23 +36,23 @@
 #
 set -euo pipefail
 
-AB_BIN="${AB_BIN:-$(command -v agent-browser || true)}"
+AB_BIN="${AB_BIN:-$(command -v kevin || true)}"
 AB_DAEMON_HOST="127.0.0.1"
 AB_DAEMON_PORT="${AB_DAEMON_PORT:-9223}"
-AB_PROFILE="${AB_PROFILE:-$HOME/.agent-browser/profile}"
+AB_PROFILE="${AB_PROFILE:-$HOME/.kevin/profile}"
 
-log()  { echo "[agent-browser-up] $*" >&2; }
+log()  { echo "[kevin-up] $*" >&2; }
 fail() { log "FAIL: $*"; exit 1; }
 
 ensure_binary() {
   if [ -z "$AB_BIN" ] || ! [ -x "$AB_BIN" ]; then
-    log "agent-browser not on PATH. Installing via npm..."
+    log "kevin not on PATH. Installing via npm..."
     command -v npm >/dev/null || fail "npm not found — install Node.js 24+ first"
-    npm install -g agent-browser
-    AB_BIN="$(command -v agent-browser)"
-    [ -x "$AB_BIN" ] || fail "agent-browser install failed"
+    npm install -g kevin
+    AB_BIN="$(command -v kevin)"
+    [ -x "$AB_BIN" ] || fail "kevin install failed"
   fi
-  log "agent-browser binary: $AB_BIN"
+  log "kevin binary: $AB_BIN"
   log "version: $($AB_BIN --version 2>/dev/null || echo 'unknown')"
 }
 
@@ -61,7 +61,7 @@ ensure_chrome() {
     log "Chrome profile already exists: $AB_PROFILE"
     return 0
   fi
-  log "Bootstrapping Chrome for Testing via agent-browser install"
+  log "Bootstrapping Chrome for Testing via kevin install"
   $AB_BIN install --silent || true
 }
 
@@ -72,7 +72,7 @@ is_daemon_running() {
 }
 
 start_daemon() {
-  log "Starting agent-browser daemon (profile: $AB_PROFILE, port: $AB_DAEMON_PORT)..."
+  log "Starting kevin daemon (profile: $AB_PROFILE, port: $AB_DAEMON_PORT)..."
   mkdir -p "$AB_PROFILE"
 
   # Spawn the daemon detached so it survives parent shell exit
@@ -89,13 +89,13 @@ start_daemon() {
   local retries=30
   while [ $retries -gt 0 ]; do
     if curl -fsS --max-time 2 "http://${AB_DAEMON_HOST}:${AB_DAEMON_PORT}/json/version" >/dev/null 2>&1; then
-      log "agent-browser daemon is up (pid $pid)"
+      log "kevin daemon is up (pid $pid)"
       return 0
     fi
     sleep 1
     retries=$((retries - 1))
   done
-  fail "agent-browser daemon did not bind to ${AB_DAEMON_HOST}:${AB_DAEMON_PORT}"
+  fail "kevin daemon did not bind to ${AB_DAEMON_HOST}:${AB_DAEMON_PORT}"
 }
 
 stop_daemon() {
@@ -104,24 +104,24 @@ stop_daemon() {
     local pid
     pid="$(cat "$pidfile" 2>/dev/null || true)"
     if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
-      log "Stopping agent-browser daemon (pid $pid)"
+      log "Stopping kevin daemon (pid $pid)"
       kill "$pid" 2>/dev/null || true
       sleep 1
       kill -9 "$pid" 2>/dev/null || true
     fi
     rm -f "$pidfile"
   fi
-  # Belt-and-braces: kill any orphan agent-browser processes
-  pkill -f 'agent-browser serve' 2>/dev/null || true
+  # Belt-and-braces: kill any orphan kevin processes
+  pkill -f 'kevin serve' 2>/dev/null || true
 }
 
 print_status() {
   if is_daemon_running; then
-    echo "agent-browser: RUNNING  (http://${AB_DAEMON_HOST}:${AB_DAEMON_PORT})"
+    echo "kevin: RUNNING  (http://${AB_DAEMON_HOST}:${AB_DAEMON_PORT})"
     $AB_BIN doctor 2>&1 | tail -20 || true
   else
-    echo "agent-browser: STOPPED"
-    echo "Start with: cli/agent-browser-up.sh start"
+    echo "kevin: STOPPED"
+    echo "Start with: cli/kevin-up.sh start"
   fi
 }
 
@@ -134,17 +134,17 @@ case "${1:-start}" in
   install) ensure_binary; ensure_chrome; $AB_BIN install ;;
   help|--help|-h)
     cat <<'AGENT_BROWSER_UP_HELP'
-agent-browser-up -- start/stop the agent-browser daemon
+kevin-up -- start/stop the kevin daemon
 
-Usage: cli/agent-browser-up.sh <command>
+Usage: cli/kevin-up.sh <command>
 
 Commands:
   start    Start the daemon (idempotent)
   stop     Stop the daemon
   restart  Stop + start
   status   Print daemon status
-  doctor   Run agent-browser doctor
-  install  Install agent-browser + download Chrome
+  doctor   Run kevin doctor
+  install  Install kevin + download Chrome
 AGENT_BROWSER_UP_HELP
     exit 0
     ;;