@jigyasudham/veto 0.8.0

package/dist/agents/memory/context-manager.js

@@ -0,0 +1,167 @@
+function detectCategory(task) {
+    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 = {
+    '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 = {
+    '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 = {
+    '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 = {
+    '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, context) {
+    const category = detectCategory(task + ' ' + (context ?? ''));
+    return {
+        agent: 'context-manager',
+        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',
+    };
+}
+//# sourceMappingURL=context-manager.js.map

package/dist/agents/memory/decision-logger.js

@@ -0,0 +1,157 @@
+function detectCategory(task) {
+    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 = {
+    '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 = {
+    '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 = {
+    '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, context) {
+    const category = detectCategory(task + ' ' + (context ?? ''));
+    return {
+        agent: 'decision-logger',
+        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',
+    };
+}
+//# sourceMappingURL=decision-logger.js.map

package/dist/agents/memory/knowledge-base.js

@@ -0,0 +1,120 @@
+function detectCategory(task) {
+    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 = {
+    '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 = {
+    '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 = {
+    '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, context) {
+    const category = detectCategory(task + ' ' + (context ?? ''));
+    return {
+        agent: 'knowledge-base',
+        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',
+    };
+}
+//# sourceMappingURL=knowledge-base.js.map

package/dist/agents/memory/pattern-learner.js

@@ -0,0 +1,140 @@
+function detectCategory(task) {
+    const t = task.toLowerCase();
+    if (t.includes('style') || t.includes('format') || t.includes('indent') || t.includes('structure') || t.includes('code pattern'))
+        return 'coding-style';
+    if (t.includes('naming') || t.includes('convention') || t.includes('variable') || t.includes('function name') || t.includes('identifier'))
+        return 'naming';
+    if (t.includes('error') || t.includes('exception') || t.includes('catch') || t.includes('throw') || t.includes('handling'))
+        return 'error-handling';
+    if (t.includes('test') || t.includes('spec') || t.includes('unit') || t.includes('mock') || t.includes('assertion'))
+        return 'testing';
+    return 'general';
+}
+const categoryApproach = {
+    'coding-style': 'Observe recurring structural patterns in the codebase: file layout, function organisation, import grouping, async patterns, class vs functional preference. Record each distinct pattern via veto_memory_store (type="pattern"). Increment confidence on re-observation. Use high-confidence patterns to guide future code generation.',
+    'naming': 'Extract naming conventions from the existing codebase: camelCase vs snake_case, file naming (kebab-case), export style (named vs default), constant casing (UPPER_SNAKE). Record as patterns with confidence scored by frequency. Apply consistently — an AI that ignores existing conventions creates noisy diffs.',
+    'error-handling': 'Identify the error-handling contract: typed errors vs raw strings, Result types vs exceptions, HTTP error mapping conventions, logging format. Record the dominant pattern so all generated code uses the same error style. Flag when new code diverges from the established pattern.',
+    'testing': 'Learn the testing conventions: framework (Jest / Vitest / Mocha), file placement (co-located vs __tests__/), describe/it nesting depth, mock style (jest.mock vs manual mocks), assertion verbosity. Record each observed pattern. Generated tests should be indistinguishable from human-written tests in this codebase.',
+    'general': 'Scan recent files modified in the session. Extract 3–5 recurring patterns that are non-obvious (not just "uses TypeScript"). Store each via veto_memory_store (type="pattern"). On subsequent observations of the same pattern, call upsertPattern to increment confidence.',
+};
+const categorySteps = {
+    'coding-style': [
+        'Read 5–10 representative source files across the codebase',
+        'Identify the dominant import grouping order (stdlib → third-party → local)',
+        'Identify async pattern: async/await vs Promise chains vs callbacks',
+        'Identify class vs functional component preference',
+        'Identify single-return vs early-return guard clause preference',
+        'Identify comment style: JSDoc, inline comments, or none',
+        'Record each as a pattern: { key: "code.async-pattern", val: "async/await with try/catch" }',
+        'Call veto_memory_store for each new pattern with type="pattern"',
+        'On subsequent observation, call upsertPattern to increase confidence',
+        'Output a pattern summary for use in future code generation prompts',
+    ],
+    'naming': [
+        'Scan file names in src/ to confirm naming convention (kebab-case, camelCase, etc.)',
+        'Read 5 files and extract variable names to confirm camelCase vs snake_case',
+        'Check constants for UPPER_SNAKE_CASE vs camelCase',
+        'Check type / interface names for PascalCase confirmation',
+        'Check function names for verb-first convention (getData vs getDataFetch)',
+        'Check boolean variable names for is/has/can prefix convention',
+        'Record each naming rule as a pattern with confidence',
+        'Flag any files that violate the dominant convention — they may be intentional exceptions',
+    ],
+    'error-handling': [
+        'Search for throw new and catch patterns across the codebase',
+        'Identify if typed error classes are used (class NotFoundError extends Error)',
+        'Identify if Result<T, E> pattern is used vs throwing',
+        'Identify the HTTP status code mapping pattern for API errors',
+        'Identify the logging format for errors (structured JSON vs console.error)',
+        'Identify if error messages are user-facing strings or internal codes',
+        'Record the dominant error pattern as high-confidence',
+        'Record any secondary patterns as lower-confidence alternatives',
+    ],
+    'testing': [
+        'Identify the test framework from package.json devDependencies',
+        'Find test files and confirm naming convention (*.test.ts vs *.spec.ts)',
+        'Confirm test file placement: co-located vs separate __tests__/ directory',
+        'Read 3 test files to identify describe/it nesting depth',
+        'Identify mock strategy: jest.mock() at top vs factory functions vs manual mocks',
+        'Identify setup/teardown patterns (beforeEach, afterEach usage)',
+        'Identify assertion library and verbosity (expect(x).toBe(y) vs x === y)',
+        'Record each pattern with confidence scored by frequency across test files',
+    ],
+    'general': [
+        'Read the 5 most recently modified source files',
+        'Extract patterns that appear in 3 or more of the files',
+        'Identify patterns that are non-obvious (not just "uses TypeScript")',
+        'For each pattern: write a key (category.pattern-name) and a concise value',
+        'Call veto_memory_store with type="pattern" for new patterns',
+        'For patterns already stored, call upsertPattern to increment confidence',
+        'Output a pattern summary listing key, value, and confidence for each learned pattern',
+    ],
+};
+const categoryChecklist = {
+    'coding-style': [
+        '[ ] At least 5 source files scanned',
+        '[ ] Async pattern identified and recorded',
+        '[ ] Import order identified and recorded',
+        '[ ] Functional vs class preference identified',
+        '[ ] Comment style identified',
+        '[ ] All patterns stored via veto_memory_store',
+        '[ ] Confidence incremented for re-observed patterns',
+    ],
+    'naming': [
+        '[ ] File naming convention confirmed',
+        '[ ] Variable naming convention confirmed',
+        '[ ] Constant naming convention confirmed',
+        '[ ] Boolean naming prefix confirmed',
+        '[ ] All naming rules stored as patterns',
+        '[ ] Convention violations flagged',
+    ],
+    'error-handling': [
+        '[ ] Typed vs untyped error strategy identified',
+        '[ ] Result type vs exception choice recorded',
+        '[ ] HTTP error mapping pattern recorded',
+        '[ ] Logging format pattern recorded',
+        '[ ] Dominant pattern stored as high-confidence',
+    ],
+    'testing': [
+        '[ ] Test framework identified',
+        '[ ] Test file naming convention recorded',
+        '[ ] Test file placement recorded',
+        '[ ] Mock strategy identified and recorded',
+        '[ ] Assertion style recorded',
+        '[ ] All patterns stored with confidence',
+    ],
+    'general': [
+        '[ ] At least 5 files scanned',
+        '[ ] Only non-obvious patterns recorded',
+        '[ ] pattern_key follows category.pattern-name format',
+        '[ ] Existing patterns updated via upsertPattern',
+        '[ ] Pattern summary outputted',
+    ],
+};
+export function plan(task, context) {
+    const category = detectCategory(task + ' ' + (context ?? ''));
+    return {
+        agent: 'pattern-learner',
+        task,
+        tier: 1,
+        approach: categoryApproach[category],
+        steps: categorySteps[category],
+        checklist: categoryChecklist[category],
+        pitfalls: [
+            'Recording obvious patterns ("uses TypeScript", "has functions") — only record non-obvious recurring choices',
+            'Treating low-frequency patterns as conventions — require at least 3 observations before treating as established',
+            'Conflating two different patterns: e.g. "async/await in services, promises in utilities" — store separately',
+            'Not incrementing confidence on re-observation — all patterns stay at 1.0 and are equally trusted',
+            'Applying learned patterns to files that deliberately deviate (e.g. legacy files, test fixtures)',
+            'Over-specifying patterns: "uses 2-space indent in coder.ts" vs "uses 2-space indent across all TypeScript files"',
+        ],
+        patterns: [
+            'Frequency-confidence: confidence increases with each additional observation of the pattern',
+            'Category namespacing: key format "category.specific-pattern" enables prefix search',
+            'Deviation detection: compare new code to stored patterns and flag significant divergence',
+            'Pattern evolution: when a pattern changes (e.g. moving from callbacks to async/await), update the stored value rather than adding a duplicate',
+        ],
+        duration_estimate: '10-20 minutes',
+    };
+}
+//# sourceMappingURL=pattern-learner.js.map