@unpolarize/code-sessions 0.1.0 → 0.2.0

package/dist/index.js

@@ -9,16 +9,21 @@ import {
   StateStore,
   THRESHOLDS,
   applyHygiene,
+  buildClaudeSkill,
+  buildLabelSkillBody,
   buildMetricPayload,
   buildPrompt,
+  buildPromptFile,
   buildTracePayload,
   claudeRunner,
   cmdBackfill,
   cmdDoctor,
   cmdExport,
+  cmdFork,
   cmdIndex,
   cmdInit,
   cmdInstallHooks,
+  cmdInstallSkills,
   cmdQuery,
   cmdReindex,
   cmdSearch,
@@ -26,6 +31,8 @@ import {
   codexSessionsRoot,
   computeEnvelope,
   defaultConfig,
+  deriveIntent,
+  deriveProjects,
   deriveSignals,
   deriveTags,
   discoverCodexSessions,
@@ -35,12 +42,14 @@ import {
   exportSession,
   exportStore,
   findTranscript,
+  forkSession,
   grokRunner,
   grokSessionsRoot,
   guessTopic,
   handleHookInput,
   insightsFile,
   installHooks,
+  installSkills,
   isSessionEndEvent,
   isoNano,
   labelSession,
@@ -59,6 +68,7 @@ import {
   parseLabelJson,
   postOtlp,
   priceFor,
+  projectIdFromPath,
   rawBlobFile,
   readEntries,
   readNewLines,
@@ -78,7 +88,7 @@ import {
   writeBlobFile,
   writeImportedSession,
   writeTurnFile
-} from "./chunk-ZJG2DWAK.js";
+} from "./chunk-HV6FQJPS.js";
 export {
   CaptureEngine,
   DEFAULT_HOOK_EVENTS,
@@ -90,16 +100,21 @@ export {
   StateStore,
   THRESHOLDS,
   applyHygiene,
+  buildClaudeSkill,
+  buildLabelSkillBody,
   buildMetricPayload,
   buildPrompt,
+  buildPromptFile,
   buildTracePayload,
   claudeRunner,
   cmdBackfill,
   cmdDoctor,
   cmdExport,
+  cmdFork,
   cmdIndex,
   cmdInit,
   cmdInstallHooks,
+  cmdInstallSkills,
   cmdQuery,
   cmdReindex,
   cmdSearch,
@@ -107,6 +122,8 @@ export {
   codexSessionsRoot,
   computeEnvelope,
   defaultConfig,
+  deriveIntent,
+  deriveProjects,
   deriveSignals,
   deriveTags,
   discoverCodexSessions,
@@ -116,12 +133,14 @@ export {
   exportSession,
   exportStore,
   findTranscript,
+  forkSession,
   grokRunner,
   grokSessionsRoot,
   guessTopic,
   handleHookInput,
   insightsFile,
   installHooks,
+  installSkills,
   isSessionEndEvent,
   isoNano,
   labelSession,
@@ -140,6 +159,7 @@ export {
   parseLabelJson,
   postOtlp,
   priceFor,
+  projectIdFromPath,
   rawBlobFile,
   readEntries,
   readNewLines,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unpolarize/code-sessions",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Headless, event-driven cross-agent session capture agent (daemon + CLI)",
   "license": "MIT",
   "type": "module",
@@ -8,14 +8,24 @@
     "code-sessions": "./bin/code-sessions.mjs"
   },
   "main": "./dist/index.js",
-  "files": ["dist", "src", "bin"],
-  "publishConfig": { "access": "public" },
-  "repository": { "type": "git", "url": "git+https://github.com/unpolarize/code-sessions.git", "directory": "packages/agent" },
+  "files": [
+    "dist",
+    "src",
+    "bin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unpolarize/code-sessions.git",
+    "directory": "packages/agent"
+  },
   "scripts": {
     "build": "tsup src/index.ts src/cli.ts --format esm --clean --out-dir dist"
   },
   "dependencies": {
-    "@unpolarize/code-sessions-schema": "^0.1.0",
+    "@unpolarize/code-sessions-schema": "^0.2.0",
     "zod": "^3.23.8"
   }
 }

package/src/cli.ts

@@ -4,9 +4,11 @@ import {
   cmdBackfill,
   cmdDoctor,
   cmdExport,
+  cmdFork,
   cmdIndex,
   cmdInit,
   cmdInstallHooks,
+  cmdInstallSkills,
   cmdQuery,
   cmdReindex,
   cmdSearch,
@@ -45,6 +47,9 @@ export async function main(argv: string[]): Promise<void> {
         }),
       );
       break;
+    case 'install-skills':
+      emit(cmdInstallSkills(typeof flags.agent === 'string' ? { agent: flags.agent as 'claude' | 'codex' | 'grok' | 'all' } : {}));
+      break;
     case 'backfill':
       emit(
         await cmdBackfill(cfg, {
@@ -78,6 +83,17 @@ export async function main(argv: string[]): Promise<void> {
       emit(cmdSearch(cfg, { query: q, ...(typeof flags.limit === 'string' ? { limit: Number(flags.limit) } : {}) }));
       break;
     }
+    case 'fork': {
+      const sid = argv.slice(1).find((a) => !a.startsWith('--')) ?? '';
+      emit(
+        cmdFork(cfg, {
+          sessionId: sid,
+          atTurn: typeof flags.at === 'string' ? Number(flags.at) : NaN,
+          ...(typeof flags.id === 'string' ? { newId: flags.id } : {}),
+        }),
+      );
+      break;
+    }
     case 'hook': {
       // Never fail the agent: swallow everything, always exit 0.
       try {

package/src/cliargs.ts

@@ -51,6 +51,7 @@ Commands:
   init            Initialize the git-backed store (~/.sessions)
   start           Run the capture daemon (foreground)
   install-hooks   Install Claude Code hooks that feed the daemon
+  install-skills  Install the cs-label-session skill into agents [--agent claude|codex|grok|all]
   hook            (internal) forward a hook payload from stdin to the daemon
   backfill        Import existing transcripts into the store [--agent claude|grok|codex|all]
   reindex         (Re)derive insights for stored sessions  [--since YYYY-MM]
@@ -58,6 +59,7 @@ Commands:
   index           (Re)build the internal SQLite index from the git store
   query           List recent sessions from the index  [--limit N] [--agent X]
   search          Full-text search session turns  <text> [--limit N]
+  fork            Fork a session at a turn ("git for sessions")  <session-id> --at N [--id X]
   analytics       Compute MVP-2 rollups + digest into analytics/
   status          Show daemon/store status
   doctor          Environment checks

package/src/commands.ts

@@ -15,6 +15,8 @@ import { discoverCodexSessions, parseCodexSession } from './adapters/codex';
 import { writeImportedSession } from './adapters/import';
 import { SessionIndex, type SessionIndexRow } from './index_store/db';
 import { syncIndex } from './index_store/sync';
+import { installSkills, type SkillAgent } from './skills/install';
+import { forkSession } from './fork';
 
 export interface CommandResult {
   code: number;
@@ -192,6 +194,35 @@ export async function cmdExport(
   };
 }
 
+export function cmdFork(
+  cfg: CodeSessionsConfig,
+  opts: { sessionId: string; atTurn: number; newId?: string },
+): CommandResult {
+  if (!opts.sessionId || Number.isNaN(opts.atTurn)) {
+    return { code: 1, output: 'usage: code-sessions fork <session-id> --at <turn> [--id <new-id>]' };
+  }
+  try {
+    const res = forkSession(cfg, {
+      sessionId: opts.sessionId,
+      atTurn: opts.atTurn,
+      ...(opts.newId ? { newSessionId: opts.newId } : {}),
+    });
+    const git = gitStoreFor(cfg);
+    if (git.isRepo()) git.commit(`fork ${opts.sessionId}@${opts.atTurn} -> ${res.newSessionId}`);
+    return {
+      code: 0,
+      output: `Forked ${opts.sessionId} at turn ${opts.atTurn} → ${res.newSessionId} (${res.turns} turns) at ${res.sessionDir}`,
+    };
+  } catch (e) {
+    return { code: 1, output: `fork failed: ${e instanceof Error ? e.message : String(e)}` };
+  }
+}
+
+export function cmdInstallSkills(opts: { agent?: SkillAgent } = {}): CommandResult {
+  const res = installSkills(opts.agent ? { agent: opts.agent } : {});
+  return { code: 0, output: `Installed cs-label-session skill:\n  ${res.installed.join('\n  ')}` };
+}
+
 export function cmdIndex(cfg: CodeSessionsConfig): CommandResult {
   const stats = syncIndex(cfg);
   return {
@@ -205,8 +236,9 @@ function fmtRow(r: SessionIndexRow): string {
   const agent = (r.agent || '?').padEnd(11).slice(0, 11);
   const tok = String(r.input_tokens + r.output_tokens).padStart(8);
   const cost = `$${r.cost_usd.toFixed(2)}`.padStart(8);
-  const title = (r.topic || r.title || r.session_id).slice(0, 48);
-  return `${date}  ${agent}  ${tok}  ${cost}  ${title}`;
+  const intent = (r.intent || '·').padEnd(8).slice(0, 8);
+  const title = (r.topic || r.title || r.session_id).slice(0, 44);
+  return `${date}  ${agent}  ${intent}  ${tok}  ${cost}  ${title}`;
 }
 
 export function cmdQuery(

package/src/fork.test.ts

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import type { Turn } from '@unpolarize/code-sessions-schema';
+import { forkSession } from './fork';
+import { envelopeFile, sessionDir, turnFile } from './store/paths';
+import { rebuildEnvelope, readTurns, writeTurnFile } from './store/writer';
+import { makeConfig, withTempDir } from './test/tmp';
+
+function turn(i: number, role: Turn['role'], text: string): Turn {
+  return {
+    schema: 'session-store/turn@1',
+    session_id: 'src',
+    host: 'h',
+    agent: 'claude-code',
+    turn_index: i,
+    ts: `2026-06-20T08:0${i}:00Z`,
+    role,
+    text,
+    tool_calls: [],
+    usage: { input_tokens: 100, output_tokens: 10, cache_read_tokens: 0, cache_write_tokens: 0 },
+    scrubbed: false,
+    raw_ref: null,
+  };
+}
+
+function seed(store: string): void {
+  const dir = sessionDir(store, 'test-host', '2026-06', 'src');
+  writeTurnFile(dir, turn(0, 'user', 'start the feature'));
+  writeTurnFile(dir, turn(1, 'assistant', 'working on it'));
+  writeTurnFile(dir, turn(2, 'user', 'change of plan'));
+  writeTurnFile(dir, turn(3, 'assistant', 'ok redoing'));
+  rebuildEnvelope(store, 'test-host', '2026-06', 'src', { model: 'claude-opus-4-8', title: 'feature work' }, {
+    session_id: 'src',
+    host: 'test-host',
+    agent: 'claude-code',
+    native_uuid: 'src',
+  });
+}
+
+describe('forkSession', () => {
+  it('branches a session at a turn with lineage', () => {
+    withTempDir((store) => {
+      seed(store);
+      const cfg = makeConfig(store);
+      const res = forkSession(cfg, { sessionId: 'src', atTurn: 1, newSessionId: 'fork1' });
+      expect(res.newSessionId).toBe('fork1');
+      expect(res.turns).toBe(2); // turns 0 and 1 only
+      expect(res.forkedFrom).toEqual({ session_id: 'src', turn_index: 1 });
+
+      const dir = sessionDir(store, 'test-host', '2026-06', 'fork1');
+      expect(existsSync(turnFile(dir, 0))).toBe(true);
+      expect(existsSync(turnFile(dir, 1))).toBe(true);
+      expect(existsSync(turnFile(dir, 2))).toBe(false); // not copied
+
+      const forkTurns = readTurns(dir);
+      expect(forkTurns.every((t) => t.session_id === 'fork1')).toBe(true);
+
+      const env = JSON.parse(readFileSync(envelopeFile(dir), 'utf8'));
+      expect(env.forked_from).toEqual({ session_id: 'src', turn_index: 1 });
+      expect(env.title).toBe('fork: feature work');
+      expect(env.native_ref.format).toBe('fork');
+    });
+  });
+
+  it('can fork into a different agent', () => {
+    withTempDir((store) => {
+      seed(store);
+      const res = forkSession(makeConfig(store), { sessionId: 'src', atTurn: 0, agent: 'grok' });
+      const env = JSON.parse(readFileSync(envelopeFile(res.sessionDir), 'utf8'));
+      expect(env.agent).toBe('grok');
+      expect(res.turns).toBe(1);
+    });
+  });
+
+  it('throws for a missing session', () => {
+    withTempDir((store) => {
+      expect(() => forkSession(makeConfig(store), { sessionId: 'nope', atTurn: 0 })).toThrow(/not found/);
+    });
+  });
+});

package/src/fork.ts

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import {
+  SCHEMA_VERSIONS,
+  safeParseSession,
+  type SessionEnvelope,
+  type Turn,
+} from '@unpolarize/code-sessions-schema';
+import type { CodeSessionsConfig } from './config';
+import { computeEnvelope, readTurns, writeTurnFile } from './store/writer';
+import { envelopeFile, monthOf, sessionDir } from './store/paths';
+import { listSessionDirs } from './store/scan';
+
+export interface ForkResult {
+  newSessionId: string;
+  sessionDir: string;
+  turns: number;
+  forkedFrom: { session_id: string; turn_index: number };
+}
+
+function locateSession(storeDir: string, sessionId: string): { dir: string } | undefined {
+  const ref = listSessionDirs(storeDir).find((r) => r.sessionId === sessionId);
+  return ref ? { dir: ref.dir } : undefined;
+}
+
+function loadEnvelope(dir: string): SessionEnvelope | undefined {
+  const p = envelopeFile(dir);
+  if (!existsSync(p)) return undefined;
+  const parsed = safeParseSession(JSON.parse(readFileSync(p, 'utf8')));
+  return parsed.success ? parsed.data : undefined;
+}
+
+function writeJsonAtomic(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`);
+  renameSync(tmp, path);
+}
+
+/**
+ * Fork a session at a turn — "git for sessions". Copies turns [0..atTurn] of the
+ * source into a NEW session keyed on this host, stamped with `forked_from`. The
+ * new session can be resumed/continued in any agent from that branch point; all
+ * turns stay discoverable via the index.
+ */
+export function forkSession(
+  cfg: CodeSessionsConfig,
+  opts: { sessionId: string; atTurn: number; newSessionId?: string; agent?: SessionEnvelope['agent'] },
+): ForkResult {
+  const located = locateSession(cfg.storeDir, opts.sessionId);
+  if (!located) throw new Error(`session not found in store: ${opts.sessionId}`);
+  const srcEnv = loadEnvelope(located.dir);
+  const allTurns = readTurns(located.dir);
+  const prefix = allTurns.filter((t) => t.turn_index <= opts.atTurn);
+  if (prefix.length === 0) throw new Error(`no turns at or before index ${opts.atTurn}`);
+
+  const newId = opts.newSessionId ?? randomUUID();
+  const agent = opts.agent ?? srcEnv?.agent ?? 'claude-code';
+  const month = monthOf(srcEnv?.started_at ?? prefix[0]?.ts);
+  const dir = sessionDir(cfg.storeDir, cfg.host, month, newId);
+
+  const newTurns: Turn[] = prefix.map((t) => ({
+    ...t,
+    session_id: newId,
+    host: cfg.host,
+    agent,
+  }));
+  for (const t of newTurns) writeTurnFile(dir, t);
+
+  const env = computeEnvelope(
+    newTurns,
+    {
+      ...(srcEnv?.model ? { model: srcEnv.model } : {}),
+      ...(srcEnv?.project_path ? { project_path: srcEnv.project_path } : {}),
+      ...(srcEnv?.title ? { title: `fork: ${srcEnv.title}` } : {}),
+    },
+    { session_id: newId, host: cfg.host, agent, native_uuid: newId },
+  );
+  env.forked_from = { session_id: opts.sessionId, turn_index: opts.atTurn };
+  env.native_ref.format = 'fork';
+  writeJsonAtomic(envelopeFile(dir), env);
+
+  return {
+    newSessionId: newId,
+    sessionDir: dir,
+    turns: newTurns.length,
+    forkedFrom: env.forked_from,
+  };
+}

package/src/index.ts

@@ -17,5 +17,7 @@ export * from './insights/index';
 export * from './telemetry/index';
 export * from './adapters/index';
 export * from './index_store/index';
+export * from './skills/index';
+export * from './fork';
 export * from './hooks/install';
 export * from './hooks/shim';

package/src/index_store/db.ts

@@ -21,7 +21,7 @@ const { DatabaseSync } = nodeRequire('node:sqlite') as {
  * can share the model.
  */
 
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 
 export interface SessionIndexRow {
   session_id: string;
@@ -39,6 +39,8 @@ export interface SessionIndexRow {
   title: string | null;
   labels: string[];
   topic: string | null;
+  intent: string | null;
+  projects: string[];
   source_path: string;
 }
 
@@ -60,7 +62,8 @@ export class SessionIndex {
 
   private migrate(): void {
     const row = this.db.prepare('PRAGMA user_version').get() as { user_version: number };
-    if ((row?.user_version ?? 0) < 1) {
+    const cur = row?.user_version ?? 0;
+    if (cur < 1) {
       this.db.exec(`
         CREATE TABLE IF NOT EXISTS session (
           session_id TEXT PRIMARY KEY,
@@ -78,6 +81,8 @@ export class SessionIndex {
           title TEXT,
           labels_json TEXT NOT NULL DEFAULT '[]',
           topic TEXT,
+          intent TEXT,
+          projects_json TEXT NOT NULL DEFAULT '[]',
           source_path TEXT NOT NULL,
           mtime_ms INTEGER NOT NULL DEFAULT 0,
           size_bytes INTEGER NOT NULL DEFAULT 0,
@@ -101,13 +106,24 @@ export class SessionIndex {
         CREATE TABLE IF NOT EXISTS insight (
           session_id TEXT PRIMARY KEY REFERENCES session(session_id) ON DELETE CASCADE,
           topic TEXT,
+          intent TEXT,
           tags_json TEXT NOT NULL DEFAULT '[]',
+          projects_json TEXT NOT NULL DEFAULT '[]',
           signals_json TEXT NOT NULL DEFAULT '[]',
           provider TEXT,
           generated_at TEXT
         );
       `);
       this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+    } else if (cur < 2) {
+      // additive v1 -> v2: intent + projects columns
+      this.db.exec(`
+        ALTER TABLE session ADD COLUMN intent TEXT;
+        ALTER TABLE session ADD COLUMN projects_json TEXT NOT NULL DEFAULT '[]';
+        ALTER TABLE insight ADD COLUMN intent TEXT;
+        ALTER TABLE insight ADD COLUMN projects_json TEXT NOT NULL DEFAULT '[]';
+        PRAGMA user_version = ${SCHEMA_VERSION};
+      `);
     }
   }
 
@@ -125,21 +141,30 @@ export class SessionIndex {
 
   upsertSession(
     env: SessionEnvelope,
-    src: { source_path: string; mtime_ms: number; size_bytes: number; indexed_at: number; topic?: string },
+    src: {
+      source_path: string;
+      mtime_ms: number;
+      size_bytes: number;
+      indexed_at: number;
+      topic?: string;
+      intent?: string;
+      projects?: string[];
+    },
   ): void {
     this.db
       .prepare(
         `INSERT INTO session (session_id, host, agent, project_path, model, started_at, ended_at,
            turn_count, tool_call_count, input_tokens, output_tokens, cost_usd, title, labels_json,
-           topic, source_path, mtime_ms, size_bytes, indexed_at)
-         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+           topic, intent, projects_json, source_path, mtime_ms, size_bytes, indexed_at)
+         VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
          ON CONFLICT(session_id) DO UPDATE SET
            host=excluded.host, agent=excluded.agent, project_path=excluded.project_path,
            model=excluded.model, started_at=excluded.started_at, ended_at=excluded.ended_at,
            turn_count=excluded.turn_count, tool_call_count=excluded.tool_call_count,
            input_tokens=excluded.input_tokens, output_tokens=excluded.output_tokens,
            cost_usd=excluded.cost_usd, title=excluded.title, labels_json=excluded.labels_json,
-           topic=excluded.topic, source_path=excluded.source_path, mtime_ms=excluded.mtime_ms,
+           topic=excluded.topic, intent=excluded.intent, projects_json=excluded.projects_json,
+           source_path=excluded.source_path, mtime_ms=excluded.mtime_ms,
            size_bytes=excluded.size_bytes, indexed_at=excluded.indexed_at`,
       )
       .run(
@@ -158,6 +183,8 @@ export class SessionIndex {
         env.title ?? null,
         JSON.stringify(env.labels ?? []),
         src.topic ?? null,
+        src.intent ?? null,
+        JSON.stringify(src.projects ?? []),
         src.source_path,
         src.mtime_ms,
         src.size_bytes,
@@ -190,13 +217,15 @@ export class SessionIndex {
   upsertInsight(ins: Insights): void {
     this.db
       .prepare(
-        `INSERT OR REPLACE INTO insight (session_id, topic, tags_json, signals_json, provider, generated_at)
-         VALUES (?,?,?,?,?,?)`,
+        `INSERT OR REPLACE INTO insight (session_id, topic, intent, tags_json, projects_json, signals_json, provider, generated_at)
+         VALUES (?,?,?,?,?,?,?,?)`,
       )
       .run(
         ins.session_id,
         ins.topic ?? null,
+        ins.intent ?? null,
         JSON.stringify(ins.tags ?? []),
+        JSON.stringify(ins.projects ?? []),
         JSON.stringify(ins.signals ?? []),
         ins.provider,
         ins.generated_at,
@@ -226,6 +255,8 @@ export class SessionIndex {
       title: r.title ?? null,
       labels: safeJson(r.labels_json),
       topic: r.topic ?? null,
+      intent: r.intent ?? null,
+      projects: safeJson(r.projects_json),
       source_path: r.source_path,
     };
   }

package/src/index_store/sync.ts

@@ -51,6 +51,8 @@ export function syncIndex(
       const env = parsed.data;
 
       let topic: string | undefined;
+      let intent: string | undefined;
+      let projects: string[] = [];
       const insPath = insightsFile(ref.dir);
       let insights = undefined;
       if (existsSync(insPath)) {
@@ -58,6 +60,8 @@ export function syncIndex(
         if (pi.success) {
           insights = pi.data;
           topic = pi.data.topic;
+          intent = pi.data.intent;
+          projects = pi.data.projects ?? [];
         }
       }
 
@@ -66,7 +70,9 @@ export function syncIndex(
         mtime_ms,
         size_bytes,
         indexed_at: now,
+        projects,
         ...(topic ? { topic } : {}),
+        ...(intent ? { intent } : {}),
       });
       index.replaceTurns(env.session_id, readTurns(ref.dir));
       if (insights) index.upsertInsight(insights);

package/src/insights/heuristics.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { Turn } from '@unpolarize/code-sessions-schema';
-import { deriveSignals, deriveTags, guessTopic } from './heuristics';
+import { deriveIntent, deriveProjects, deriveSignals, deriveTags, guessTopic } from './heuristics';
 
 function turn(i: number, over: Partial<Turn> = {}): Turn {
   return {
@@ -69,3 +69,25 @@ describe('guessTopic / deriveTags', () => {
     expect(tags.sort()).toEqual(['Edit', 'Read']);
   });
 });
+
+describe('deriveIntent', () => {
+  it('classifies intent from the first user prompt', () => {
+    expect(deriveIntent([turn(0, { role: 'user', text: 'fix the parser bug' })])).toBe('bugfix');
+    expect(deriveIntent([turn(0, { role: 'user', text: 'add a dark mode feature' })])).toBe('feature');
+    expect(deriveIntent([turn(0, { role: 'user', text: 'refactor the auth module' })])).toBe('refactor');
+    expect(deriveIntent([turn(0, { role: 'user', text: 'research the best vector db' })])).toBe('research');
+    expect(deriveIntent([turn(0, { role: 'user', text: 'xyzzy' })])).toBe('other');
+    expect(deriveIntent([])).toBeUndefined();
+  });
+});
+
+describe('deriveProjects', () => {
+  it('derives project ids from edited file paths', () => {
+    const projects = deriveProjects([
+      turn(0, { tool_calls: [{ name: 'Edit', input: { file_path: '/Users/x/projects/foo/a.ts' } }] }),
+      turn(1, { tool_calls: [{ name: 'Write', input: { file_path: '/Users/x/projects/ai/bar/b.ts' } }] }),
+      turn(2, { tool_calls: [{ name: 'Read', input: { path: '/Users/x/docs/notes.md' } }] }),
+    ]);
+    expect(projects).toEqual(['ai/bar', 'docs', 'foo']);
+  });
+});