@jigyasudham/veto 0.8.2 → 1.0.0

package/src/agents/executor.ts

@@ -1,158 +0,0 @@
-import { AgentTask, AgentResult, WorkerAgentType } from './types.js';
-
-// Development agents
-import * as coder from './development/coder.js';
-import * as reviewer from './development/reviewer.js';
-import * as tester from './development/tester.js';
-import * as debugger_ from './development/debugger.js';
-import * as refactor from './development/refactor.js';
-import * as database from './development/database.js';
-import * as api from './development/api.js';
-import * as frontend from './development/frontend.js';
-import * as backend from './development/backend.js';
-import * as devops from './development/devops.js';
-import * as performance from './development/performance.js';
-import * as migration from './development/migration.js';
-
-// Security agents
-import * as securityScanner from './security/scanner.js';
-import * as auth from './security/auth.js';
-import * as privacy from './security/privacy.js';
-import * as secrets from './security/secrets.js';
-import * as dependencyAudit from './security/dependency-audit.js';
-import * as penetration from './security/penetration.js';
-
-// Memory agents
-import * as contextManager from './memory/context-manager.js';
-import * as decisionLogger from './memory/decision-logger.js';
-import * as projectMapper from './memory/project-mapper.js';
-import * as patternLearner from './memory/pattern-learner.js';
-import * as knowledgeBase from './memory/knowledge-base.js';
-
-// Research agents
-import * as researcher from './research/researcher.js';
-import * as techAdvisor from './research/tech-advisor.js';
-import * as costAnalyzer from './research/cost-analyzer.js';
-import * as competitorAnalyzer from './research/competitor-analyzer.js';
-import * as riskAssessor from './research/risk-assessor.js';
-import * as estimator from './research/estimator.js';
-import * as ethicsBias from './research/ethics-bias.js';
-
-// Quality agents
-import * as codeQuality from './quality/code-quality.js';
-import * as documentation from './quality/documentation.js';
-import * as accessibility from './quality/accessibility.js';
-import * as compatibility from './quality/compatibility.js';
-import * as errorHandling from './quality/error-handling.js';
-
-// Workflow agents
-import * as taskPlanner from './workflow/task-planner.js';
-import * as taskCoordinator from './workflow/task-coordinator.js';
-import * as fileManager from './workflow/file-manager.js';
-import * as gitAgent from './workflow/git-agent.js';
-import * as searchAgent from './workflow/search-agent.js';
-import * as reporter from './workflow/reporter.js';
-import * as automation from './workflow/automation.js';
-
-// Agents that support analyze()
-const ANALYZE_CAPABLE: Set<WorkerAgentType> = new Set([
-  'reviewer',
-  'security-scanner',
-  'secrets',
-  'dependency-audit',
-  'code-quality',
-  'documentation',
-  'accessibility',
-  'error-handling',
-]);
-
-type AgentModule = {
-  plan: (task: string, context?: string) => import('./types.js').AgentPlan;
-  analyze?: (code: string, context?: string) => import('./types.js').AgentAnalysis;
-};
-
-function resolveAgent(agentType: WorkerAgentType): AgentModule {
-  switch (agentType) {
-    case 'coder':            return coder;
-    case 'reviewer':         return reviewer;
-    case 'tester':           return tester;
-    case 'debugger':         return debugger_;
-    case 'refactor':         return refactor;
-    case 'database':         return database;
-    case 'api':              return api;
-    case 'frontend':         return frontend;
-    case 'backend':          return backend;
-    case 'devops':           return devops;
-    case 'performance':      return performance;
-    case 'migration':        return migration;
-    case 'security-scanner': return securityScanner;
-    case 'auth':             return auth;
-    case 'privacy':          return privacy;
-    case 'secrets':          return secrets;
-    case 'dependency-audit': return dependencyAudit;
-    case 'penetration':      return penetration;
-    case 'context-manager':  return contextManager;
-    case 'decision-logger':  return decisionLogger;
-    case 'project-mapper':   return projectMapper;
-    case 'pattern-learner':  return patternLearner;
-    case 'knowledge-base':      return knowledgeBase;
-    case 'researcher':          return researcher;
-    case 'tech-advisor':        return techAdvisor;
-    case 'cost-analyzer':       return costAnalyzer;
-    case 'competitor-analyzer': return competitorAnalyzer;
-    case 'risk-assessor':       return riskAssessor;
-    case 'estimator':           return estimator;
-    case 'ethics-bias':         return ethicsBias;
-    case 'code-quality':        return codeQuality;
-    case 'documentation':       return documentation;
-    case 'accessibility':       return accessibility;
-    case 'compatibility':       return compatibility;
-    case 'error-handling':      return errorHandling;
-    case 'task-planner':        return taskPlanner;
-    case 'task-coordinator':    return taskCoordinator;
-    case 'file-manager':        return fileManager;
-    case 'git-agent':           return gitAgent;
-    case 'search-agent':        return searchAgent;
-    case 'reporter':            return reporter;
-    case 'automation':          return automation;
-    default:
-      throw new Error(`Unknown agent type: ${agentType}`);
-  }
-}
-
-export async function executeOne(task: AgentTask): Promise<AgentResult> {
-  const start = Date.now();
-  try {
-    const agent = resolveAgent(task.agent);
-    const useAnalyze = task.code !== undefined && ANALYZE_CAPABLE.has(task.agent);
-
-    if (useAnalyze && agent.analyze) {
-      const analysis = agent.analyze(task.code!, task.context);
-      return {
-        id: task.id,
-        agent: task.agent,
-        analysis,
-        duration_ms: Date.now() - start,
-      };
-    } else {
-      const plan = agent.plan(task.task, task.context);
-      return {
-        id: task.id,
-        agent: task.agent,
-        plan,
-        duration_ms: Date.now() - start,
-      };
-    }
-  } catch (err) {
-    return {
-      id: task.id,
-      agent: task.agent,
-      duration_ms: Date.now() - start,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-export async function executeParallel(tasks: AgentTask[]): Promise<AgentResult[]> {
-  return Promise.all(tasks.map(task => executeOne(task)));
-}

package/src/agents/memory/context-manager.ts

@@ -1,171 +0,0 @@
-import { AgentPlan, WorkerAgentType } from '../types.js';
-
-type ContextCategory = 'session-start' | 'mid-task' | 'context-switch' | 'compression' | 'general';
-
-function detectCategory(task: string): ContextCategory {
-  const t = task.toLowerCase();
-  if (t.includes('start') || t.includes('begin') || t.includes('new session') || t.includes('initialize')) return 'session-start';
-  if (t.includes('compress') || t.includes('trim') || t.includes('reduce') || t.includes('shrink') || t.includes('token')) return 'compression';
-  if (t.includes('switch') || t.includes('handoff') || t.includes('transfer') || t.includes('gemini') || t.includes('codex')) return 'context-switch';
-  if (t.includes('mid') || t.includes('checkpoint') || t.includes('save') || t.includes('continue')) return 'mid-task';
-  return 'general';
-}
-
-const categoryApproach: Record<ContextCategory, string> = {
-  'session-start': 'Load prior session via veto_session_restore. Identify the active project, last completed task, and immediate next action. Build a compact working context — goals, constraints, key files, recent decisions. Discard old context that no longer applies.',
-  'mid-task': 'Snapshot current progress to context: completed subtasks, in-progress work, emerging blockers. Trim historical conversation that is no longer load-bearing. Keep all active decisions and constraints live. Evaluate whether token budget warrants a save-and-compress cycle.',
-  'context-switch': 'Serialize current context to a portable session snapshot. Include task state, file manifest, active decisions, and next action. Write to veto_session_save. Confirm the receiving platform can restore and resume without re-reading source files.',
-  'compression': 'Identify context tiers: critical (keep verbatim), summarisable (compress to 1–3 sentences), droppable (no longer relevant). Apply the router\'s context-compressor module. Target < 30% of original token count while preserving all active constraints and decisions.',
-  'general': 'Audit the current context window for relevance. Remove completed subtasks, resolved blockers, and superseded decisions. Elevate forward-looking content — pending work, live constraints, open questions. Summarise historical content to 1–2 sentences per topic.',
-};
-
-const categorySteps: Record<ContextCategory, string[]> = {
-  'session-start': [
-    'Call veto_sessions_list to find the most recent session for this project directory',
-    'Call veto_session_restore with the session ID to load prior context',
-    'Parse the restored task_state to identify completed, in-progress, and remaining work',
-    'Call veto_memory_search with the project_dir to load relevant knowledge base entries',
-    'Call veto_project_map_get to load the current codebase structure',
-    'Synthesise a compact active-context object: goals, constraints, key files, decisions',
-    'Identify the single most important next action and make it the session focus',
-    'Discard any context older than the last significant decision or file change',
-  ],
-  'mid-task': [
-    'List what has been completed since the last save',
-    'Identify what is currently in progress and what is blocked',
-    'Score each context item: critical | summarisable | droppable',
-    'Draft a compressed context string using summarisable items',
-    'Trigger a session save if token count exceeds 8,000 or a subtask just completed',
-    'Record any new decisions or discoveries to veto_memory_store',
-    'Update the project map if new files were created or deleted',
-    'Verify the next action is concrete and unambiguous',
-  ],
-  'context-switch': [
-    'Freeze the current session: write final progress state',
-    'Call veto_session_save with full task_state including phase, progress, decisions',
-    'Note the session ID — give it to the human to paste into the receiving platform',
-    'Confirm the session summary is self-contained (receiving agent needs no prior context)',
-    'Include the file manifest for files that were read or modified this session',
-    'Include the single next action as the last line of the context',
-    'Verify the save by calling veto_sessions_list and inspecting the new row',
-  ],
-  'compression': [
-    'Count current context tokens using the router\'s compressor estimate',
-    'Identify the compression target: what percentage reduction is needed?',
-    'Categorise each context block: verbatim | summarise | drop',
-    'Keep all active constraints, open blockers, and pending tasks verbatim',
-    'Summarise historical completed work to one sentence per subtask',
-    'Drop resolved blockers, superseded decisions, and read-back confirmations',
-    'Verify compressed context passes a completeness check: can the task still be continued?',
-    'Save the compressed state as a new session checkpoint',
-  ],
-  'general': [
-    'Audit the context for items that are no longer relevant to the current task phase',
-    'Identify decisions that have been superseded and mark them deprecated',
-    'Summarise completed subtask history into single-sentence progress notes',
-    'Elevate forward-looking items to the top of the active context',
-    'Ensure all active file paths and module names are accurate (not stale)',
-    'Record new patterns or solutions to the knowledge base',
-    'Save the refined context as a session checkpoint',
-  ],
-};
-
-const categoryChecklist: Record<ContextCategory, string[]> = {
-  'session-start': [
-    '[ ] Prior session restored via veto_session_restore',
-    '[ ] Task phase identified: planning | implementing | reviewing | blocked',
-    '[ ] Completed subtasks listed — no re-doing finished work',
-    '[ ] Remaining subtasks listed in priority order',
-    '[ ] All active file paths verified to exist',
-    '[ ] Active constraints and decisions loaded from session',
-    '[ ] Knowledge base queried for relevant prior solutions',
-    '[ ] Project map loaded — key modules and entry points known',
-    '[ ] Next action is a single concrete step, not a vague direction',
-  ],
-  'mid-task': [
-    '[ ] Progress snapshot written: completed, in-progress, remaining',
-    '[ ] New decisions or discoveries logged to knowledge base',
-    '[ ] Stale context removed — no completed blockers still listed as active',
-    '[ ] Session saved if checkpoint warranted (> 8k tokens or subtask complete)',
-    '[ ] Project map updated if files were added or removed',
-    '[ ] Next action re-confirmed: single concrete step',
-  ],
-  'context-switch': [
-    '[ ] Session saved with full task_state before switching platforms',
-    '[ ] Session ID recorded and ready to give to receiving platform',
-    '[ ] Summary is self-contained — receiving agent needs no prior context',
-    '[ ] File manifest included in session save',
-    '[ ] Next action is the final line of the context',
-    '[ ] Receiving platform tested with veto_session_restore before committing to switch',
-  ],
-  'compression': [
-    '[ ] Original token count measured before compression',
-    '[ ] Compression target set (aim for < 30% of original)',
-    '[ ] All active constraints preserved verbatim',
-    '[ ] Completed work compressed to one sentence per subtask',
-    '[ ] No active blockers or decisions removed',
-    '[ ] Compressed context passes completeness check',
-    '[ ] Compressed state saved as new session checkpoint',
-  ],
-  'general': [
-    '[ ] Context audit completed — stale items removed',
-    '[ ] All file paths verified to be current',
-    '[ ] Decisions table up to date — no deprecated decisions still marked accepted',
-    '[ ] Knowledge base updated with new findings',
-    '[ ] Session saved with current state',
-    '[ ] Next action is concrete and prioritised',
-  ],
-};
-
-const categoryPitfalls: Record<ContextCategory, string[]> = {
-  'session-start': [
-    'Starting work before restoring prior session — redoing completed subtasks',
-    'Loading the session but ignoring the task_state — treating the session as read-only',
-    'Not checking the project map — assuming file structure from memory instead of current state',
-    'Taking the next action from the prior session without checking if it is still valid',
-  ],
-  'mid-task': [
-    'Waiting until 50k tokens to compress — forces an emergency compression that risks losing context',
-    'Saving a session without a nextAction — the restoring agent starts from scratch',
-    'Not recording decisions to the knowledge base — the same decision gets relitigated next session',
-    'Updating the project map only on session end — missing interim file creates/deletes',
-  ],
-  'context-switch': [
-    'Switching platforms without calling veto_session_save first — all progress lost',
-    'Including raw file contents in the session save instead of file paths — balloons token cost',
-    'Not testing restore on the receiving platform before committing to the switch',
-    'Switching while a destructive operation (migration, deploy) is in progress',
-  ],
-  'compression': [
-    'Compressing active constraints as if they were completed work — causes silent constraint violations',
-    'Over-compressing: removing the rationale for active decisions — future agent reverses them',
-    'Not saving the compressed context — compression is lost at next context switch',
-    'Targeting a fixed token number without checking completeness — may cut load-bearing context',
-  ],
-  'general': [
-    'Context drift: the active context describes a different version of the task than the current one',
-    'Stale file paths in context that no longer exist in the project',
-    'Decisions still listed as "proposed" that have already been implemented',
-    'Context growing monotonically without pruning — each session inherits all prior context',
-  ],
-};
-
-export function plan(task: string, context?: string): AgentPlan {
-  const category = detectCategory(task + ' ' + (context ?? ''));
-  return {
-    agent: 'context-manager' as WorkerAgentType,
-    task,
-    tier: 1,
-    approach: categoryApproach[category],
-    steps: categorySteps[category],
-    checklist: categoryChecklist[category],
-    pitfalls: categoryPitfalls[category],
-    patterns: [
-      'Checkpoint pattern: save context at phase boundaries, not only at session end',
-      'Minimal viable context: enough to resume work, not a full transcript',
-      'Tiered retention: verbatim | summarised | dropped — never binary keep/delete',
-      'Forward-first ordering: next actions at the top, completed history at the bottom',
-    ],
-    duration_estimate: '5-15 minutes',
-  };
-}

package/src/agents/memory/decision-logger.ts

@@ -1,160 +0,0 @@
-import { AgentPlan, WorkerAgentType } from '../types.js';
-
-type DecisionCategory = 'architecture' | 'security' | 'data' | 'api' | 'general';
-
-function detectCategory(task: string): DecisionCategory {
-  const t = task.toLowerCase();
-  if (t.includes('architect') || t.includes('design') || t.includes('structure') || t.includes('pattern') || t.includes('framework')) return 'architecture';
-  if (t.includes('auth') || t.includes('security') || t.includes('encrypt') || t.includes('permission') || t.includes('token')) return 'security';
-  if (t.includes('schema') || t.includes('database') || t.includes('migration') || t.includes('model') || t.includes('table')) return 'data';
-  if (t.includes('api') || t.includes('endpoint') || t.includes('contract') || t.includes('version') || t.includes('rest') || t.includes('graphql')) return 'api';
-  return 'general';
-}
-
-const categoryApproach: Record<DecisionCategory, string> = {
-  'architecture': 'Document the architectural decision as an ADR. Capture context (what forces are in play), the decision made, full rationale, rejected alternatives with reasons, and positive/negative consequences. Store in veto_memory_store with type="decision". Link from code comments using the ADR ID.',
-  'security': 'Log the security decision with threat model context. State the attack surface being protected, the chosen control, why alternatives were rejected (too weak, too complex, operational burden), and any residual risk accepted. Tag with "security" for fast retrieval during reviews.',
-  'data': 'Record the data schema decision with migration path. Document the constraints that drove the schema choice (access patterns, cardinality, denormalisation trade-offs). Include the rollback plan if the decision proves wrong. Tag with "schema" and affected table names.',
-  'api': 'Log the API contract decision including versioning strategy. Capture backward-compatibility commitments, breaking-change triggers, and the client impact. Once an API contract is published, record it as immutable unless a version bump is logged.',
-  'general': 'Use the ADR format: context → decision → rationale → alternatives → consequences. Log to veto_memory_store (type="decision") and the local decisions table. Reference the ADR ID in code comments near the implementation.',
-};
-
-const categorySteps: Record<DecisionCategory, string[]> = {
-  'architecture': [
-    'Assign a sequential ADR ID (ADR-001, ADR-002, …)',
-    'Write the context: what forces, constraints, or requirements make this choice necessary?',
-    'State the decision in one unambiguous sentence',
-    'Document the rationale: why this option over alternatives?',
-    'List at least two alternatives that were genuinely considered',
-    'For each alternative: pros, cons, and the specific reason it was rejected',
-    'Document positive consequences: what does this decision enable?',
-    'Document negative consequences: what technical debt or constraints does it introduce?',
-    'Set status: proposed | accepted | deprecated | superseded-by:ADR-xxx',
-    'Add file references to the implementation',
-    'Call veto_memory_store with type="decision", title=ADR ID, tags=["architecture"]',
-    'Add // See ADR-001 comment near the implementation',
-  ],
-  'security': [
-    'Describe the threat being mitigated (attack vector, affected asset, likelihood)',
-    'State the chosen security control in one sentence',
-    'Document why weaker alternatives were rejected (OWASP reference where applicable)',
-    'Document why stronger alternatives were not chosen (operational burden, complexity, cost)',
-    'Quantify residual risk: what attack surface remains after this control?',
-    'Reference relevant standards: OWASP, NIST, RFC',
-    'Set a review date — security decisions should be re-evaluated annually',
-    'Call veto_memory_store with type="decision", tags=["security", threat category]',
-    'Add SECURITY-DECISION comment near the implementation with a reference link',
-  ],
-  'data': [
-    'Describe the access patterns this schema must support',
-    'State the chosen schema structure (table names, key columns, relationships)',
-    'Document denormalisation choices: what query performance trade-off justifies them?',
-    'Document normalisation choices: what integrity benefit justifies the join cost?',
-    'Write the migration plan: how to move existing data to the new schema?',
-    'Write the rollback plan: how to revert if the schema proves wrong?',
-    'Note index strategy: which columns need indexes and why?',
-    'Call veto_memory_store with type="decision", tags=["schema", table name]',
-    'Record the decision_id in the migration file comment',
-  ],
-  'api': [
-    'Define the API contract: method, path, request shape, response shape',
-    'State the versioning strategy: URL path (/v1/), header, or content negotiation',
-    'Document backward-compatibility commitments for this version',
-    'List fields that must never be removed or renamed without a version bump',
-    'Define breaking-change criteria: what requires a new major version?',
-    'Document deprecation timeline if replacing an existing endpoint',
-    'Reference the OpenAPI spec file path',
-    'Call veto_memory_store with type="decision", tags=["api-contract", endpoint path]',
-    'Add OpenAPI operation ID that matches the decision ID for traceability',
-  ],
-  'general': [
-    'Assign an ADR ID if this is a durable architectural decision',
-    'Write the context: what problem or constraint is being addressed?',
-    'State the decision clearly in one sentence',
-    'Document the rationale with at least two sentences of "why"',
-    'List alternatives that were considered and rejected',
-    'Identify the primary consequence: what does this decision make easier and harder?',
-    'Call veto_memory_store with type="decision", title, and relevant tags',
-    'If the decision affects code, add a reference comment near the implementation',
-    'Set a review trigger: what event should prompt re-evaluating this decision?',
-  ],
-};
-
-const categoryChecklist: Record<DecisionCategory, string[]> = {
-  'architecture': [
-    '[ ] ADR ID assigned sequentially',
-    '[ ] Context section explains forces in play, not just the problem statement',
-    '[ ] Decision stated in one clear sentence',
-    '[ ] Rationale answers "why this over alternatives"',
-    '[ ] At least two alternatives documented with rejection reason',
-    '[ ] Positive consequences listed',
-    '[ ] Negative consequences / technical debt acknowledged',
-    '[ ] Status set to "accepted"',
-    '[ ] Stored in veto_memory_store with type="decision"',
-    '[ ] Code comment added: // See ADR-xxx',
-  ],
-  'security': [
-    '[ ] Threat clearly described: vector, asset, likelihood',
-    '[ ] Chosen control stated',
-    '[ ] Weaker alternatives rejected with reason',
-    '[ ] Residual risk quantified',
-    '[ ] OWASP or NIST reference included where applicable',
-    '[ ] Review date set',
-    '[ ] Stored with tags=["security"]',
-  ],
-  'data': [
-    '[ ] Access patterns documented before schema choice',
-    '[ ] Schema decision stated with table/column names',
-    '[ ] Migration plan included',
-    '[ ] Rollback plan included',
-    '[ ] Index strategy documented',
-    '[ ] Stored with tags=["schema", table name]',
-    '[ ] Migration file references the decision ID',
-  ],
-  'api': [
-    '[ ] Endpoint contract fully specified',
-    '[ ] Versioning strategy stated',
-    '[ ] Backward-compatibility commitments listed',
-    '[ ] Breaking-change criteria defined',
-    '[ ] Deprecation plan if replacing existing endpoint',
-    '[ ] OpenAPI spec path referenced',
-    '[ ] Stored with tags=["api-contract"]',
-  ],
-  'general': [
-    '[ ] Decision stated in one clear sentence',
-    '[ ] Rationale documented',
-    '[ ] Alternatives listed with rejection reasons',
-    '[ ] Primary consequence identified',
-    '[ ] Stored in veto_memory_store',
-    '[ ] Code comment added if decision affects implementation',
-    '[ ] Review trigger identified',
-  ],
-};
-
-export function plan(task: string, context?: string): AgentPlan {
-  const category = detectCategory(task + ' ' + (context ?? ''));
-  return {
-    agent: 'decision-logger' as WorkerAgentType,
-    task,
-    tier: 1,
-    approach: categoryApproach[category],
-    steps: categorySteps[category],
-    checklist: categoryChecklist[category],
-    pitfalls: [
-      'Logging the decision after the fact with hindsight bias — capture original thinking at decision time',
-      'Writing the "what" without the "why" — future engineers see the choice but not the reasoning',
-      'Only logging the chosen option without alternatives — looks like no deliberation happened',
-      'Forgetting to update the status when a decision is superseded — stale "accepted" entries cause confusion',
-      'Using vague titles like "Auth decision" instead of "Use JWT with rotating refresh tokens"',
-      'Not linking the ADR from the implementation — the decision and code drift apart',
-      'Logging trivial decisions (variable names) — reserve the log for non-obvious, hard-to-reverse choices',
-    ],
-    patterns: [
-      'ADR (Architecture Decision Record): context → decision → rationale → alternatives → consequences',
-      'Decision-in-context: co-locate decision reference with implementation via code comments',
-      'Living document: update status (deprecated / superseded-by) rather than deleting entries',
-      'Decision chain: reference prior ADRs that this decision builds on or overrides',
-    ],
-    duration_estimate: '15-30 minutes',
-  };
-}

package/src/agents/memory/knowledge-base.ts

@@ -1,124 +0,0 @@
-import { AgentPlan, WorkerAgentType } from '../types.js';
-
-type KBCategory = 'store-solution' | 'search' | 'dedup' | 'general';
-
-function detectCategory(task: string): KBCategory {
-  const t = task.toLowerCase();
-  if (t.includes('store') || t.includes('save') || t.includes('record') || t.includes('add to') || t.includes('log solution')) return 'store-solution';
-  if (t.includes('find') || t.includes('search') || t.includes('retrieve') || t.includes('look up') || t.includes('query')) return 'search';
-  if (t.includes('dedup') || t.includes('duplicate') || t.includes('clean') || t.includes('merge')) return 'dedup';
-  return 'general';
-}
-
-const categoryApproach: Record<KBCategory, string> = {
-  'store-solution': 'Before storing, check for a similar existing entry via veto_memory_search to avoid duplicates. If found, update the existing entry. If new, store via veto_memory_store with a precise title, type classification (solution/pattern/error/reference), relevant tags, and the project_dir for scoped retrieval. A good knowledge entry is self-contained: a future agent should understand and apply it without the original context.',
-  'search': 'Query the knowledge base via veto_memory_search before starting any task. Use type filters and tags to narrow results. Combine a keyword query with the project_dir filter for project-scoped results. Search for prior errors before debugging — the same error may already be solved. Search for patterns before writing code — the established style may already be documented.',
-  'dedup': 'Search for entries with similar titles using multiple keyword variants. Group semantically similar entries. Merge by: keeping the entry with higher relevance, combining the content, and deleting the duplicate. Update the merged entry\'s tags to include all tags from both entries.',
-  'general': 'Check the knowledge base at the start of every task (veto_memory_search). Store new solutions, discovered patterns, and resolved errors after every task. Keep entries self-contained and searchable. Prune stale entries that no longer apply to the current codebase version.',
-};
-
-const categorySteps: Record<KBCategory, string[]> = {
-  'store-solution': [
-    'Identify what type this entry is: solution | pattern | error | reference | decision | context',
-    'Write a precise, searchable title (not "Fixed the bug" — use "Fix: Node 22 sqlite binding fails on Windows without --experimental-sqlite flag")',
-    'Write content that is self-contained: problem statement → root cause → solution steps → outcome',
-    'Choose 3–5 tags that describe the topic, technology, and error category',
-    'Set project_dir if this is project-specific knowledge (not general programming knowledge)',
-    'Search veto_memory_search for similar entries before storing',
-    'If a similar entry exists: update it, do not create a duplicate',
-    'If new: call veto_memory_store with all fields populated',
-    'Confirm storage by searching for the entry by title',
-  ],
-  'search': [
-    'Identify the key terms of what you are searching for',
-    'Call veto_memory_search with query=key terms, type filter if known',
-    'If results are empty: try synonyms or broader terms',
-    'Add project_dir filter for project-specific knowledge',
-    'Read the top 3 results — check relevance and recency',
-    'If an old result has been superseded by a newer approach, mark the old entry for deletion',
-    'Apply the found solution or pattern directly if the context matches',
-    'If the context is different from the stored entry, adapt the solution and update the entry with the new context',
-  ],
-  'dedup': [
-    'Search for entries with the same title or very similar titles',
-    'Search for entries with the same tags to find topic overlap',
-    'Group semantically similar entries',
-    'For each duplicate group: identify the most complete and accurate entry to keep',
-    'Merge content: combine unique information from all entries into the survivor',
-    'Merge tags: union of all tags across the group',
-    'Set the survivor\'s relevance to the maximum of the group',
-    'Delete duplicate entries via veto_memory_search (note IDs) + internal delete',
-    'Confirm dedup by re-running the search — only one entry should appear per topic',
-  ],
-  'general': [
-    'At session start: call veto_memory_search with the current task description',
-    'Review results for prior solutions, patterns, or errors that apply to this task',
-    'During the task: note any new solutions, patterns, or errors discovered',
-    'At session end: store all new knowledge via veto_memory_store',
-    'Check for duplicates before each store',
-    'Periodically review low-relevance entries and delete stale ones',
-    'Keep the knowledge base scoped: use project_dir for project-specific entries',
-  ],
-};
-
-const categoryChecklist: Record<KBCategory, string[]> = {
-  'store-solution': [
-    '[ ] Type classification chosen: solution | pattern | error | reference | decision | context',
-    '[ ] Title is precise and searchable — not vague',
-    '[ ] Content is self-contained (problem → root cause → solution)',
-    '[ ] At least 3 tags chosen',
-    '[ ] project_dir set if project-specific',
-    '[ ] Duplicate search performed before storing',
-    '[ ] Entry confirmed via follow-up search',
-  ],
-  'search': [
-    '[ ] Knowledge base queried before starting the task',
-    '[ ] Synonyms tried if initial query returns empty results',
-    '[ ] Top 3 results evaluated for relevance',
-    '[ ] Stale results flagged for deletion',
-    '[ ] Found solution adapted to current context if needed',
-  ],
-  'dedup': [
-    '[ ] Title-based and tag-based search performed',
-    '[ ] Duplicate groups identified',
-    '[ ] Best entry per group selected',
-    '[ ] Content merged',
-    '[ ] Tags merged',
-    '[ ] Duplicates deleted',
-    '[ ] Dedup confirmed by re-search',
-  ],
-  'general': [
-    '[ ] Knowledge base searched at session start',
-    '[ ] New knowledge stored at session end',
-    '[ ] No duplicates created',
-    '[ ] Stale entries reviewed',
-  ],
-};
-
-export function plan(task: string, context?: string): AgentPlan {
-  const category = detectCategory(task + ' ' + (context ?? ''));
-  return {
-    agent: 'knowledge-base' as WorkerAgentType,
-    task,
-    tier: 1,
-    approach: categoryApproach[category],
-    steps: categorySteps[category],
-    checklist: categoryChecklist[category],
-    pitfalls: [
-      'Storing entries with vague titles — "Fixed bug" is not searchable; "Fix: X fails when Y" is',
-      'Creating duplicate entries — always search before storing',
-      'Storing entries without tags — makes retrieval rely entirely on full-text search',
-      'Storing project-specific knowledge without project_dir — it bleeds into unrelated projects',
-      'Not searching the knowledge base before starting a task — solving the same problem twice',
-      'Keeping stale entries after the codebase has moved on — old solutions become misleading',
-      'Storing too much: copying entire file contents instead of the key insight',
-    ],
-    patterns: [
-      'Search-first: always query the knowledge base before solving a problem from scratch',
-      'Self-contained entries: each entry stands alone — future agent needs no original context',
-      'Type-and-tag taxonomy: type (solution/pattern/error/reference/decision) + tags enables faceted retrieval',
-      'Dedup-on-write: search for duplicates before every store operation',
-    ],
-    duration_estimate: '5-15 minutes',
-  };
-}