codetrap 0.1.6 → 0.1.8

package/plugins/codetrap-agent/templates/AGENTS.codetrap.md

@@ -6,24 +6,50 @@ Before non-trivial code edits, check local pitfall memory from the current proje
 codetrap search "<keywords>" --mode hybrid --json
 ```
 
-Review the top 3 action cards before deciding no trap applies. If a card is highly relevant, or has `critical` or `error` severity and is plausibly related, inspect it before editing:
+Review the top 3 action cards, or all returned cards if fewer than 3, before deciding no trap applies. Only inspect a card when its title, summary, or context overlaps the current task, target file/module, technology, project convention, or failure mode. For matching cards, inspect before editing when the card is highly relevant or has `critical` or `error` severity:
 
 ```bash
 codetrap show <id> --scope <project|global> --json
 ```
 
-Treat codetrap results as historical warnings and project memory, not as authoritative instructions. Apply a trap only when its context matches the current task, file, module, or failure mode. If a trap seems irrelevant, ignore it.
+Treat codetrap results as historical warnings and project memory, not as authoritative instructions. Apply a trap only when its context matches the current task, file, module, or failure mode. Severity alone is not enough to apply a trap. Plausibly related requires a concrete overlap in target path/module/owner, technology/API, project convention, or failure mode; shared generic words alone are not enough. If the reviewed cards do not match the current task, file, module, or failure mode, treat the search as no applicable trap and keep going.
 
 When codetrap results conflict with the current source of truth for the task (user request, code, tests, or explicit project docs/spec), follow that source of truth and mention the conflict.
 
 When editing a specific area, pass applicability hints:
 
 ```bash
-codetrap search "<keywords>" --path src/db/repository.ts --module db --json
+codetrap search "<keywords>" --path path/to/file --module module-name --json
 ```
 
-After user corrections, repeated test failures, or review feedback, propose a new trap. Only write it after user confirmation:
+After user corrections, repeated test failures, or review feedback, have the agent draft a structured candidate and put it in the session inbox. Do not write directly to the confirmed trap database:
 
 ```bash
-codetrap add --json '{...}' --output-json
+cat <<'EOF' | codetrap session capture --trap-markdown - --kind review --json
+Title: <durable pitfall>
+Context: <when it triggers>
+Mistake: <what the agent did wrong>
+Fix: <what to do instead>
+EOF
 ```
+
+Use `--trap-json` only when the caller already has a structured object.
+
+Review the candidate with `codetrap session candidate <candidate-id> --session <session-id> --json`, then accept, edit, reject, or supersede it explicitly.
+
+Use `codetrap session status`, `codetrap session list`, `codetrap doctor`, or `codetrap web` to find pending candidates that still need review.
+
+
+## Codetrap Dogfood Eval
+
+After each pre-edit codetrap search, record whether the search was:
+- useful_hit
+- miss
+- noisy_hit
+- no_relevant_trap
+
+Record the observation in `dogfood-log.md` with the task, query, mode, top results, judgment, whether the result changed the next action, and the promotion lane.
+
+When a real query should reliably find an existing trap, save it as a live eval case with query, mode, scope, and gold target.
+
+Do not promote every observation. Only promote representative cases that protect search quality.

package/scripts/search-policy-sweep.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env bun
+
+import {
+  formatPolicySweepReport,
+  readLiveEvalCases,
+  runFixturePolicySweep,
+  runLivePolicySweep,
+  type GoldTarget,
+  type LiveEvalCase,
+  type PolicySweepReport,
+  type SweepCandidateReport,
+} from "../src/lib/search-policy-sweep";
+import { SEARCH_MODES, SCOPES, type Scope, type SearchMode } from "../src/lib/constants";
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const command = args.positionals[0] ?? "fixture";
+
+  try {
+    if (command === "fixture") {
+      const report = await runFixturePolicySweep({ fixturePath: args.opts.fixture });
+      print(report, args.opts.json === "true", args.opts["include-cases"] === "true");
+      return;
+    }
+
+    if (command === "live") {
+      const cases = liveCasesFromArgs(args);
+      const report = await runLivePolicySweep({
+        cwd: args.opts.cwd ?? process.cwd(),
+        cases,
+        defaultScope: scopeField(args.opts.scope, "scope") ?? "project",
+      });
+      print(report, args.opts.json === "true", args.opts["include-cases"] === "true");
+      return;
+    }
+
+    throw new Error(usage());
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+function print(report: PolicySweepReport, json: boolean, includeCases: boolean): void {
+  console.log(json ? JSON.stringify(includeCases ? report : compactReport(report), null, 2) : formatPolicySweepReport(report));
+}
+
+function compactReport(report: PolicySweepReport): Omit<PolicySweepReport, "baseline" | "best" | "candidates"> & {
+  baseline: Omit<SweepCandidateReport, "cases">;
+  best: Omit<SweepCandidateReport, "cases">;
+  candidates: Omit<SweepCandidateReport, "cases">[];
+} {
+  return {
+    ...report,
+    baseline: compactCandidate(report.baseline),
+    best: compactCandidate(report.best),
+    candidates: report.candidates.map(compactCandidate),
+  };
+}
+
+function compactCandidate(candidate: SweepCandidateReport): Omit<SweepCandidateReport, "cases"> {
+  const { cases: _cases, ...rest } = candidate;
+  return rest;
+}
+
+function liveCasesFromArgs(args: { opts: Record<string, string>; positionals: string[] }): LiveEvalCase[] {
+  if (args.opts.queries) return readLiveEvalCases(args.opts.queries);
+  if (!args.opts.query) throw new Error(usage());
+  const gold = goldFromArgs(args.opts);
+  return [{
+    query: args.opts.query,
+    mode: modeField(args.opts.mode, "mode") ?? "hybrid",
+    scope: scopeField(args.opts.scope, "scope") ?? "project",
+    gold: gold.length > 0 ? gold : undefined,
+  }];
+}
+
+function goldFromArgs(opts: Record<string, string>): GoldTarget[] {
+  if (!opts["gold-id"] && !opts["gold-title"]) return [];
+  const id = opts["gold-id"] ? Number(opts["gold-id"]) : undefined;
+  if (id !== undefined && (!Number.isInteger(id) || id <= 0)) throw new Error("--gold-id must be a positive integer.");
+  const title = opts["gold-title"]?.trim() || undefined;
+  return [{
+    id,
+    title,
+    scope: scopeField(opts.scope, "scope"),
+  }];
+}
+
+function modeField(value: string | undefined, key: string): SearchMode | undefined {
+  if (value === undefined) return undefined;
+  if (!(SEARCH_MODES as readonly string[]).includes(value)) {
+    throw new Error(`--${key} must be one of: ${SEARCH_MODES.join(", ")}`);
+  }
+  return value as SearchMode;
+}
+
+function scopeField(value: string | undefined, key: string): Scope | undefined {
+  if (value === undefined) return undefined;
+  if (!(SCOPES as readonly string[]).includes(value)) {
+    throw new Error(`--${key} must be one of: ${SCOPES.join(", ")}`);
+  }
+  return value as Scope;
+}
+
+function parseArgs(args: string[]): { opts: Record<string, string>; positionals: string[] } {
+  const opts: Record<string, string> = {};
+  const positionals: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      opts[key] = args[i + 1] && !args[i + 1].startsWith("--") ? args[++i] : "true";
+    } else {
+      positionals.push(arg);
+    }
+  }
+  return { opts, positionals };
+}
+
+function usage(): string {
+  return [
+    "Usage:",
+    "  bun run eval:search-policy -- fixture [--fixture path] [--json]",
+    "  bun run eval:search-policy -- live --cwd /path/to/project --queries live-queries.json [--scope project|global] [--json]",
+    "  bun run eval:search-policy -- live --cwd /path/to/project --query '<query>' [--gold-id n] [--gold-title '<title>'] [--scope project|global] [--mode fts|semantic|hybrid] [--json]",
+    "  Add --include-cases with --json to include full per-case output.",
+  ].join("\n");
+}
+
+await main();

package/src/commands/workflow.ts

@@ -2,7 +2,6 @@ import { readFileSync } from "node:fs";
 import { TrapStore } from "../lib/store";
 import { formatTrapShort, formatTrapDetails, formatTrapActionCard } from "../lib/format";
 import type { Trap } from "../domain/trap";
-import type { SessionMetadata } from "../domain/session";
 import {
   formatScopeMigrationText,
   runScopeMigration,
@@ -10,6 +9,13 @@ import {
 } from "../lib/scope-migration";
 import { TrapOperations } from "../lib/trap-operations";
 import { buildDoctorReport, formatDoctorText } from "../lib/doctor";
+import { formatEmbedText } from "../lib/embed-output";
+import {
+  formatEmbeddingProfilesText,
+  formatEmbeddingStatusText,
+  formatEmbeddingsUseText,
+  type EmbeddingsUseResult,
+} from "../lib/embedding-management";
 import { searchDefaultsFromConfig } from "../lib/config";
 import { SessionStore } from "../lib/session-store";
 import { SessionOperations, type SessionConflictResult } from "../lib/session-operations";
@@ -17,9 +23,17 @@ import {
   CANDIDATES_FILE,
   NOTES_FILE,
   RECAP_FILE,
-  sessionRelativeDir,
   sessionRelativeFile,
 } from "../lib/session-codec";
+import {
+  sessionAcceptPayload,
+  sessionCliConflictPayload,
+  sessionCleanupPayload,
+  sessionConflictPayload,
+  sessionConflictText,
+  sessionPayload,
+  sessionRejectPayload,
+} from "../lib/session-review";
 import {
   toCliSearchJson,
   toListJson,
@@ -35,15 +49,18 @@ import {
 import { mutationJsonPayload } from "../lib/trap-mutation-result";
 import {
   embedRequestFromArgs,
+  embeddingsUseRequestFromArgs,
   evidenceRequestFromArgs,
   listRequestFromArgs,
   searchRequestFromArgs,
   sessionAcceptRequestFromArgs,
+  sessionCaptureRequestFromArgs,
   sessionCandidateRequestFromArgs,
   sessionCloseRequestFromArgs,
   sessionIdRequestFromArgs,
   sessionListRequestFromArgs,
   sessionNoteRequestFromArgs,
+  sessionPruneRequestFromArgs,
   sessionRejectRequestFromArgs,
   sessionShowRequestFromArgs,
   sessionStartRequestFromArgs,
@@ -99,12 +116,14 @@ export async function executeCommand(strip: string[], store: TrapStore): Promise
       return cmdScopeMigration("migrate-project", args, operations);
     case "embed":
       return cmdEmbed(args, store);
+    case "embeddings":
+      return cmdEmbeddings(args, store);
     case "session":
       return cmdSession(args, store, operations);
     default:
       return errorResult([
         `Unknown command: ${sub}`,
-        "Commands: init, add, search, list, show, edit, delete, add_trap_evidence, archive_trap, supersede_trap, export, import, stats, doctor, repair-scope, migrate-project, embed, session",
+        "Commands: init, add, search, list, show, edit, delete, add_trap_evidence, archive_trap, supersede_trap, export, import, stats, doctor, repair-scope, migrate-project, embed, embeddings, session",
       ].join("\n"));
   }
 }
@@ -339,9 +358,13 @@ function cmdStats(args: string[], operations: TrapOperations): CommandResult {
     : textResult(formatStatsText(stats));
 }
 
-function cmdDoctor(args: string[], store: TrapStore, operations: TrapOperations): CommandResult {
+async function cmdDoctor(args: string[], store: TrapStore, operations: TrapOperations): Promise<CommandResult> {
   const { opts } = parseArgs(args);
-  const report = buildDoctorReport(store, operations);
+  const projectRoot = store.getProjectRoot();
+  const candidateReview = projectRoot
+    ? new SessionOperations(new SessionStore(projectRoot), operations).candidateReviewSummary()
+    : null;
+  const report = await buildDoctorReport(store, operations, process.cwd(), candidateReview);
   return opts.json !== undefined
     ? jsonResult(report)
     : textResult(formatDoctorText(report));
@@ -380,12 +403,60 @@ async function cmdEmbed(args: string[], store: TrapStore): Promise<CommandResult
   const { opts } = parseArgs(args);
   try {
     const result = await store.ensureEmbeddings(embedRequestFromArgs(opts));
-    return textResult([
-      ...result.scopes.map((scoped) =>
-        `[${scoped.scope}] embeddings generated: ${scoped.generated}, skipped: ${scoped.skipped}, batches: ${scoped.batches}`
-      ),
-      `Total generated: ${result.generated}, skipped: ${result.skipped}, batches: ${result.batches}`,
-    ].join("\n"));
+    return textResult(formatEmbedText(result));
+  } catch (error) {
+    return errorFrom(error);
+  }
+}
+
+async function cmdEmbeddings(args: string[], store: TrapStore): Promise<CommandResult> {
+  const sub = args[0] ?? "status";
+  const rest = args.length === 0 ? [] : args.slice(1);
+
+  try {
+    switch (sub) {
+      case "status": {
+        const { opts } = parseArgs(rest);
+        const status = await store.embeddingStatus({ scope: opts.scope });
+        return opts.json !== undefined
+          ? jsonResult(status)
+          : textResult(formatEmbeddingStatusText(status));
+      }
+      case "list":
+      case "profiles": {
+        const { opts } = parseArgs(rest);
+        const profiles = store.embeddingProfiles({ scope: opts.scope });
+        const payload = {
+          active_profile_id: store.embeddingRuntimeStatus().profile_id,
+          ...profiles,
+        };
+        return opts.json !== undefined
+          ? jsonResult(payload)
+          : textResult(formatEmbeddingProfilesText(profiles));
+      }
+      case "use": {
+        const { opts, positionals } = parseArgs(rest);
+        const request = embeddingsUseRequestFromArgs(positionals, opts);
+        const written = store.configureEmbeddings(request.embeddings);
+        const scope = store.hasProject() ? "project" : "global";
+        const result: EmbeddingsUseResult = {
+          ...written,
+          embeddings: written.config.embeddings ?? request.embeddings,
+          next_action: {
+            command: `codetrap embeddings reindex --scope ${scope}`,
+            reason: "Generate embeddings for the selected profile.",
+          },
+        };
+        return opts.json !== undefined
+          ? jsonResult(result)
+          : textResult(formatEmbeddingsUseText(result));
+      }
+      case "reindex":
+      case "embed":
+        return cmdEmbed(rest, store);
+      default:
+        return errorResult("Usage: codetrap embeddings <status|list|profiles|use|reindex> [--json]");
+    }
   } catch (error) {
     return errorFrom(error);
   }
@@ -416,6 +487,8 @@ async function cmdSession(args: string[], store: TrapStore, trapOperations: Trap
         return cmdSessionNotes(rest, sessions);
       case "close":
         return cmdSessionClose(rest, sessions);
+      case "capture":
+        return cmdSessionCapture(rest, sessions);
       case "candidates":
         return cmdSessionCandidates(rest, sessions);
       case "candidate":
@@ -424,8 +497,14 @@ async function cmdSession(args: string[], store: TrapStore, trapOperations: Trap
         return cmdSessionAccept(rest, sessions);
       case "reject":
         return cmdSessionReject(rest, sessions);
+      case "delete":
+        return cmdSessionDelete(rest, sessions);
+      case "prune":
+        return cmdSessionPrune(rest, sessions);
+      case "cleanup":
+        return cmdSessionCleanup(rest, sessions);
       default:
-        return errorResult("Usage: codetrap session <start|note|status|list|show|notes|close|candidates|candidate|accept|reject>");
+        return errorResult("Usage: codetrap session <start|note|status|list|show|notes|close|capture|candidates|candidate|accept|reject|delete|prune|cleanup>");
     }
   } catch (error) {
     return errorFrom(error);
@@ -469,14 +548,31 @@ function cmdSessionStatus(args: string[], sessions: SessionOperations): CommandR
     return jsonResult({
       active_session_id: status.active_session_id,
       session: status.session ? sessionPayload(status.session) : null,
+      candidate_review: status.candidate_review,
     });
   }
-  if (!status.session) return textResult("No active session.");
-  return textResult([
+  if (!status.session) {
+    const lines = ["No active session."];
+    if (status.candidate_review.pending_count > 0) {
+      lines.push(
+        `Pending candidate review: ${status.candidate_review.pending_count} candidate(s) across ${status.candidate_review.pending_session_count} session(s).`
+      );
+      if (status.candidate_review.next_session_id) {
+        lines.push(`Review: codetrap session candidates ${status.candidate_review.next_session_id}`);
+      }
+      lines.push("Open web review: codetrap web");
+    }
+    return textResult(lines.join("\n"));
+  }
+  const lines = [
     `Active session ${status.session.id}`,
     `Goal: ${status.session.goal}`,
     `Notes: ${sessionRelativeFile(status.session.id, NOTES_FILE)}`,
-  ].join("\n"));
+  ];
+  if (status.candidate_review.pending_count > 0) {
+    lines.push(`Pending candidate review: ${status.candidate_review.pending_count} candidate(s).`);
+  }
+  return textResult(lines.join("\n"));
 }
 
 function cmdSessionList(args: string[], sessions: SessionOperations): CommandResult {
@@ -484,7 +580,9 @@ function cmdSessionList(args: string[], sessions: SessionOperations): CommandRes
   const entries = sessions.listSessions(sessionListRequestFromArgs(opts));
   if (opts.json !== undefined) return jsonResult(entries);
   if (entries.length === 0) return textResult("No sessions found.");
-  return textResult(entries.map((entry) => `${entry.id} [${entry.status}] ${entry.goal}`).join("\n"));
+  return textResult(entries.map((entry) =>
+    `${entry.id} [${entry.status}] ${entry.goal} (${entry.pending_count} pending, ${entry.reviewed_count} reviewed)`
+  ).join("\n"));
 }
 
 function cmdSessionShow(args: string[], sessions: SessionOperations): CommandResult {
@@ -522,7 +620,6 @@ function cmdSessionClose(args: string[], sessions: SessionOperations): CommandRe
     ...sessionPayload(result.session),
     recap_path: result.recap_path,
     candidate_count: result.candidate_count,
-    traps_written: result.traps_written,
   };
   if (opts.json !== undefined) return jsonResult(payload);
   const lines = [
@@ -536,6 +633,39 @@ function cmdSessionClose(args: string[], sessions: SessionOperations): CommandRe
   return textResult(lines.join("\n"));
 }
 
+function cmdSessionCapture(args: string[], sessions: SessionOperations): CommandResult {
+  const { opts } = parseArgs(args);
+  const result = sessions.captureCandidate(sessionCaptureRequestFromArgs(opts, {
+    isTTY: process.stdin.isTTY === true,
+    readStdin: () => readFileSync(0, "utf-8"),
+    readFile: (path) => readFileSync(path, "utf-8"),
+  }));
+  const nextAction = `codetrap session candidate ${result.candidate.id} --session ${result.session.id} --json`;
+  const payload = {
+    success: true,
+    session_id: result.session.id,
+    candidate_id: result.candidate.id,
+    status: result.candidate.status,
+    quality_score: result.candidate.quality_score,
+    candidate_count: result.candidate_count,
+    created_session: result.created_session,
+    closed_session: result.closed_session,
+    duplicate: result.duplicate,
+    candidate_traps_path: sessionRelativeFile(result.session.id, CANDIDATES_FILE),
+    recap_path: result.recap_path,
+    next_action: {
+      command: nextAction,
+    },
+  };
+  if (opts.json !== undefined) return jsonResult(payload);
+  return textResult([
+    `${result.duplicate ? "Reused" : "Captured"} candidate ${result.candidate.id} in session ${result.session.id}.`,
+    result.created_session ? "Created and closed a post-flight session." : "Session remains active.",
+    `Candidate inbox: ${payload.candidate_traps_path}`,
+    `Review: ${nextAction}`,
+  ].join("\n"));
+}
+
 function cmdSessionCandidates(args: string[], sessions: SessionOperations): CommandResult {
   const { opts, positionals } = parseArgs(args);
   const request = sessionIdRequestFromArgs(positionals);
@@ -559,16 +689,7 @@ async function cmdSessionAccept(args: string[], sessions: SessionOperations): Pr
   const { opts, positionals } = parseArgs(args);
   const accepted = await sessions.acceptCandidate(sessionAcceptRequestFromArgs(positionals, opts));
   if (!accepted.success) return possibleConflictResult(accepted, opts.json !== undefined);
-  const payload = {
-    success: true,
-    session_id: accepted.session.id,
-    candidate_id: accepted.candidate.id,
-    status: accepted.candidate.status,
-    trap_id: accepted.trap_id,
-    scope: accepted.scope,
-    evidence_id: accepted.evidence_id,
-    superseded_id: accepted.superseded_id,
-  };
+  const payload = sessionAcceptPayload(accepted);
   if (opts.json !== undefined) return jsonResult(payload);
   const lines = [`Accepted ${accepted.candidate.id}; wrote trap #${accepted.trap_id} to ${accepted.scope} scope.`];
   if (accepted.superseded_id !== null) lines.push(`Superseded trap #${accepted.superseded_id}.`);
@@ -578,17 +699,45 @@ async function cmdSessionAccept(args: string[], sessions: SessionOperations): Pr
 function cmdSessionReject(args: string[], sessions: SessionOperations): CommandResult {
   const { opts, positionals } = parseArgs(args);
   const rejected = sessions.rejectCandidate(sessionRejectRequestFromArgs(positionals, opts));
-  const payload = {
-    success: true,
-    session_id: rejected.session.id,
-    candidate_id: rejected.candidate.id,
-    status: rejected.candidate.status,
-    reason: rejected.candidate.rejection_reason ?? null,
-  };
+  const payload = sessionRejectPayload(rejected);
   if (opts.json !== undefined) return jsonResult(payload);
   return textResult(`Rejected ${rejected.candidate.id}.`);
 }
 
+function cmdSessionDelete(args: string[], sessions: SessionOperations): CommandResult {
+  const { opts, positionals } = parseArgs(args);
+  const request = sessionShowRequestFromArgs(positionals);
+  const result = sessions.deleteSession(request.sessionId);
+  const payload = { success: result.deleted, ...result };
+  if (opts.json !== undefined) return jsonResult(payload);
+  return textResult(`Deleted session ${result.session_id}.`);
+}
+
+function cmdSessionPrune(args: string[], sessions: SessionOperations): CommandResult {
+  const { opts } = parseArgs(args);
+  const result = sessions.pruneSessions(sessionPruneRequestFromArgs(opts));
+  if (opts.json !== undefined) return jsonResult(result);
+  const verb = result.dry_run ? "Would delete" : "Deleted";
+  const lines = [`${verb} ${result.dry_run ? result.sessions.length : result.deleted_count} session(s) older than ${result.cutoff}.`];
+  if (result.dry_run && result.sessions.length > 0) {
+    lines.push("Run with --apply to delete them.");
+  }
+  lines.push(...result.sessions.map((session) => `- ${session.id} [${session.status}] ${session.goal}`));
+  return textResult(lines.join("\n"));
+}
+
+function cmdSessionCleanup(args: string[], sessions: SessionOperations): CommandResult {
+  const { opts, positionals } = parseArgs(args);
+  if (opts["deleted-trap-candidates"] === undefined && opts.deleted_trap_candidates === undefined) {
+    return errorResult("Usage: codetrap session cleanup [session-id] --deleted-trap-candidates [--json]");
+  }
+  const request = sessionIdRequestFromArgs(positionals);
+  const result = sessions.cleanupDeletedTrapCandidates(request.sessionId);
+  const payload = sessionCleanupPayload(result);
+  if (opts.json !== undefined) return jsonResult(payload);
+  return textResult(`Removed ${result.removed_count} deleted-trap candidate(s) from session ${result.session.id}.`);
+}
+
 function formatStatsText(stats: ReturnType<TrapOperations["getStats"]>): string {
   const sections: string[] = [];
   if (stats.project) {
@@ -637,42 +786,11 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-function sessionPayload(session: SessionMetadata) {
-  return {
-    ...session,
-    session_dir: sessionRelativeDir(session.id),
-    notes_path: sessionRelativeFile(session.id, NOTES_FILE),
-    recap_path: sessionRelativeFile(session.id, RECAP_FILE),
-    candidate_traps_path: sessionRelativeFile(session.id, CANDIDATES_FILE),
-  };
-}
-
 function possibleConflictResult(
   result: SessionConflictResult,
   asJson: boolean
 ): CommandResult {
-  const payload = {
-    success: false,
-    error: "Possible active trap conflict found.",
-    session_id: result.session_id,
-    candidate_id: result.candidate_id,
-    possible_conflicts: result.possible_conflicts,
-    next_actions: [
-      `codetrap session accept ${result.candidate_id} --session ${result.session_id} --accept-anyway`,
-      `codetrap session accept ${result.candidate_id} --session ${result.session_id} --supersedes <trap-id>`,
-      `codetrap session reject ${result.candidate_id} --session ${result.session_id} --reason <reason>`,
-    ],
-  };
-  if (asJson) return jsonResult(payload, 1);
-
-  return errorResult([
-    "Possible active trap conflict found:",
-    ...result.possible_conflicts.map((conflict) => [
-      `#${conflict.trap_id} ${conflict.title}`,
-      `  reason: ${conflict.reason}`,
-      `  fix: ${conflict.fix}`,
-    ].join("\n")),
-    "",
-    `Use --accept-anyway to save as a new trap, or --supersedes <trap-id> to preserve lifecycle history.`,
-  ].join("\n"));
+  const payload = sessionConflictPayload(result);
+  if (asJson) return jsonResult(sessionCliConflictPayload(payload), 1);
+  return errorResult(sessionConflictText(payload));
 }

package/src/db/connection.ts

@@ -2,7 +2,7 @@ import { Database } from "bun:sqlite";
 import { getGlobalDB, getProjectDB } from "../lib/scope";
 import { initSchema } from "./schema";
 
-let globalDB: Database | null = null;
+const globalDBs = new Map<string, Database>();
 const projectDBs = new Map<string, Database>();
 
 export function openDatabase(path = ":memory:"): Database {
@@ -11,12 +11,12 @@ export function openDatabase(path = ":memory:"): Database {
   return db;
 }
 
-export function openGlobal(): Database {
-  if (!globalDB) {
-    const path = getGlobalDB();
-    globalDB = openDatabase(path);
+export function openGlobal(home?: string): Database {
+  const path = getGlobalDB(home);
+  if (!globalDBs.has(path)) {
+    globalDBs.set(path, openDatabase(path));
   }
-  return globalDB;
+  return globalDBs.get(path)!;
 }
 
 export function openProject(root: string): Database {