memory-journal-mcp 7.6.1 → 7.7.0

package/dist/{chunk-SYTB5YNH.js → chunk-ARLYSFSI.js}

@@ -2381,6 +2381,10 @@ var ENTRY_TYPES = [
   "flag",
   "system_integration_test",
   "test_entry",
+  "plan_draft",
+  "adversarial_review",
+  "plan_refinement",
+  "copilot_validation",
   "other"
 ];
 var SIGNIFICANCE_TYPES = [
@@ -3331,7 +3335,10 @@ function getSearchTools(context) {
           }
           return {
             success: true,
-            entries: personalEntries,
+            entries: personalEntries.map((e) => ({
+              ...e,
+              source: "personal"
+            })),
             count: personalEntries.length,
             degraded: false
           };
@@ -4117,6 +4124,10 @@ var VALID_ENTRY_TYPES = /* @__PURE__ */ new Set([
   "milestone",
   "system_integration_test",
   "test_entry",
+  "plan_draft",
+  "adversarial_review",
+  "plan_refinement",
+  "copilot_validation",
   "other"
 ]);
 function toEntryType(value) {
@@ -6985,7 +6996,7 @@ function getBackupTools(context) {
       description: "Restore the journal database from a backup file. WARNING: This replaces all current data. Enforce single-writer / single-instance only for restore-capable deployments. An automatic backup is created before restore.",
       group: "backup",
       inputSchema: z.object({
-        filename: z.string().describe("Backup filename to restore from (e.g., backup_2025-01-01.db)"),
+        filename: z.string().optional().describe("Backup filename to restore from (e.g., backup_2025-01-01.db)"),
         confirm: z.boolean().optional().describe("Must be set to true to confirm the restore operation")
       }),
       outputSchema: RestoreResultOutputSchema,
@@ -6998,7 +7009,7 @@ function getBackupTools(context) {
       handler: async (params) => {
         try {
           const input = z.object({
-            filename: z.string(),
+            filename: z.string().min(1, "filename cannot be empty"),
             confirm: z.boolean().optional()
           }).parse(params);
           if (!input.confirm) {

package/dist/{chunk-DFQG7UR5.js → chunk-QCQPAF4I.js}

@@ -1,4 +1,4 @@
-import { TOOL_GROUPS, logger, getGitHubIntegration, parseToolFilter, getFilterSummary, getToolFilterFromEnv, getTools, getRequiredScope, getEnabledGroups, callTool, MetricsAccumulator, getAuthContext, getRequestContext, ConfigurationError, sendProgress, SUPPORTED_SCOPES, enforceAccessBoundary, runWithAuthContext, isValidScope, requestContextStorage, ConnectionError, ResourceNotFoundError, QueryError, assertNoPathTraversal, ValidationError, resolveGitHubRepo, isResourceError, markUntrustedContentInline, milestoneCompletionPct, sanitizeAuthor, markUntrustedContent, parseFlagContext, DEFAULT_FLAG_VOCABULARY, parseScopes, BASE_SCOPES, validateDateFormatPattern, getAllToolNames, assertSafeFilePath, assertSafeDirectoryPath, MemoryJournalMcpError, sanitizeSearchQuery, DEFAULT_BRIEFING_CONFIG } from './chunk-SYTB5YNH.js';
+import { TOOL_GROUPS, logger, getGitHubIntegration, parseToolFilter, getFilterSummary, getToolFilterFromEnv, getTools, getRequiredScope, getEnabledGroups, callTool, MetricsAccumulator, getAuthContext, getRequestContext, ConfigurationError, sendProgress, SUPPORTED_SCOPES, enforceAccessBoundary, runWithAuthContext, isValidScope, requestContextStorage, ConnectionError, ResourceNotFoundError, QueryError, assertNoPathTraversal, ValidationError, resolveGitHubRepo, isResourceError, markUntrustedContentInline, milestoneCompletionPct, sanitizeAuthor, markUntrustedContent, parseFlagContext, DEFAULT_FLAG_VOCABULARY, parseScopes, BASE_SCOPES, validateDateFormatPattern, getAllToolNames, assertSafeFilePath, assertSafeDirectoryPath, MemoryJournalMcpError, sanitizeSearchQuery, DEFAULT_BRIEFING_CONFIG } from './chunk-ARLYSFSI.js';
 import { createRequire } from 'module';
 import { appendFile, open, mkdir, stat, rename } from 'fs/promises';
 import * as path4 from 'path';
@@ -2144,8 +2144,12 @@ var BackupManager = class {
       const tempDbPath = `${this.ctx.getDbPath()}.restore_tmp_${randomUUID()}`;
       await fs2.promises.copyFile(backupPath, tempDbPath);
       try {
-        await fs2.promises.rename(this.ctx.getDbPath(), oldDbBackupPath);
-        await fs2.promises.rename(tempDbPath, this.ctx.getDbPath());
+        await fs2.promises.copyFile(this.ctx.getDbPath(), oldDbBackupPath);
+        try {
+          await fs2.promises.rename(tempDbPath, this.ctx.getDbPath());
+        } catch {
+          await fs2.promises.copyFile(tempDbPath, this.ctx.getDbPath());
+        }
         await this.ctx.initialize();
         const integrityResult = this.ctx.exec("PRAGMA integrity_check");
         if (integrityResult[0]?.values[0]?.[0] !== "ok") {
@@ -2155,19 +2159,39 @@ var BackupManager = class {
         }
         try {
           await fs2.promises.unlink(oldDbBackupPath);
+          await fs2.promises.unlink(tempDbPath);
         } catch {
         }
       } catch (error) {
-        logger.error(
-          "Restore failed, rolling back to pre-restore backup using atomic rename",
-          {
-            module: "SqliteAdapter",
-            operation: "restoreFromFile",
-            error: error instanceof Error ? error.message : String(error)
-          }
-        );
+        logger.error("Restore failed, rolling back to pre-restore backup using copy", {
+          module: "SqliteAdapter",
+          operation: "restoreFromFile",
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
         this.ctx.closeDbBeforeRestore();
-        await fs2.promises.rename(oldDbBackupPath, this.ctx.getDbPath());
+        let rollbackSuccess = false;
+        try {
+          await fs2.promises.copyFile(oldDbBackupPath, this.ctx.getDbPath());
+          rollbackSuccess = true;
+        } catch (rollbackErr) {
+          if (rollbackErr.code !== "ENOENT") {
+            logger.error("Rollback copy failed", { error: rollbackErr });
+          }
+        }
+        if (rollbackSuccess) {
+          try {
+            await fs2.promises.unlink(oldDbBackupPath);
+          } catch {
+          }
+        }
+        try {
+          await fs2.promises.unlink(tempDbPath);
+        } catch {
+        }
+        if (!rollbackSuccess) {
+          throw new Error(`CRITICAL: Database restore failed AND rollback failed. The database may be in an inconsistent state. Your previous database is preserved at: ${oldDbBackupPath}. Original error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
         await this.ctx.initialize();
         throw error;
       }
@@ -3816,7 +3840,8 @@ var MS_PER_DAY = 864e5;
 function buildRulesFileInfo(rulesFilePath, allowedIoRoots = []) {
   if (!rulesFilePath) return void 0;
   try {
-    assertSafeFilePath(rulesFilePath, allowedIoRoots);
+    const expandedRoots = [...allowedIoRoots, path4.dirname(rulesFilePath)];
+    assertSafeFilePath(rulesFilePath, expandedRoots);
     const stat2 = fs2.statSync(rulesFilePath);
     const ageMs = Date.now() - stat2.mtimeMs;
     const ageHours = Math.floor(ageMs / MS_PER_HOUR);
@@ -3840,7 +3865,8 @@ function buildRulesFileInfo(rulesFilePath, allowedIoRoots = []) {
 function buildSkillsDirInfo(skillsDirPath, allowedIoRoots = []) {
   if (!skillsDirPath) return void 0;
   try {
-    assertSafeDirectoryPath(skillsDirPath, allowedIoRoots);
+    const expandedRoots = [...allowedIoRoots, skillsDirPath];
+    assertSafeDirectoryPath(skillsDirPath, expandedRoots);
     const entries = fs2.readdirSync(skillsDirPath, { withFileTypes: true });
     const skillDirs = entries.filter((e) => e.isDirectory());
     return {
@@ -4196,6 +4222,7 @@ var CORE_INSTRUCTIONS = `# memory-journal-mcp
    - **FORMATTING**: Group related properties (use \`<br>\` for line breaks).
    - **REQUIRED GROUPS**: GitHub, Issues, Entry Counts, Latest Entries/Summaries, Analytics, Milestones, Workspaces.
 6. **STOP & WAIT**: Do NOT autonomously resume past tasks or start work on new issues. The briefing is strictly for context.
+
 - **AntiGravity**: Tools are \`mcp_{name}_{tool}\` \u2192 server name = \`memory-journal-mcp\`
 - **Cursor**: Tools are \`user-{name}-{tool}\` \u2192 server name = \`user-memory-journal-mcp\`
 - **Other clients**: Use configured name exactly. Use tool-prefix discovery if unsure.
@@ -4243,7 +4270,7 @@ When you notice the user consistently applies patterns, preferences, or workflow
 
 ### Native Agent Skills (NPM Distribution)
 
-This server leverages the \`neverinfamous-agent-skills\` package. If the user's \`SKILLS_DIR_PATH\` environment variable targets these, you have native access to foundational frameworks (\`mastering-typescript\`, \`react-best-practices\`, \`playwright-standard\`, \`golang\`, \`rust\`, \`python\`, \`docker\`, \`tailwind-css\`, \`shadcn-ui\`) and the \`github-commander\` DevOps workflows (\`issue-triage\`, \`pr-review\`, \`github-actions\`, etc.).
+This server leverages the \`neverinfamous-agent-skills\` package. If the user's \`SKILLS_DIR_PATH\` environment variable targets these, you have native access to foundational frameworks (\`typescript\`, \`react-best-practices\`, \`playwright-standard\`, \`golang\`, \`rust\`, \`python\`, \`docker\`, \`tailwind-css\`, \`shadcn-ui\`) and the \`github-commander\` DevOps workflows (\`issue-triage\`, \`pr-review\`, \`github-actions\`, \`copilot-audit\`, etc.). The \`adversarial-planner\` skill provides multi-pass plan review with structured critique stages.
 
 - The user can distribute or update these skills across their repositories by running \`npx neverinfamous-agent-skills@latest\`.
 - If you need to create a new skill, reference the bundled \`skill-builder\` instructions!
@@ -6910,7 +6937,7 @@ function getHelpResourceDefinitions() {
 var toolIndexModule = null;
 async function getAllToolDefinitionsAsync(context) {
   try {
-    toolIndexModule ??= await import('./tools-JQPK5JFS.js');
+    toolIndexModule ??= await import('./tools-P4VGG4FH.js');
     if (toolIndexModule === null) return [];
     const tools = toolIndexModule.getTools(context.db, null);
     return tools.map((t) => ({

package/dist/cli.js

@@ -1,5 +1,5 @@
-import { VERSION, DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES, createServer } from './chunk-DFQG7UR5.js';
-import { logger } from './chunk-SYTB5YNH.js';
+import { VERSION, DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES, createServer } from './chunk-QCQPAF4I.js';
+import { logger } from './chunk-ARLYSFSI.js';
 import { Command } from 'commander';
 import * as path from 'path';
 import * as fs from 'fs';

package/dist/index.d.ts

@@ -183,7 +183,7 @@ interface ToolFilterConfig {
 /**
  * Entry types for journal entries
  */
-type EntryType = 'personal_reflection' | 'project_decision' | 'technical_achievement' | 'bug_fix' | 'feature_implementation' | 'code_review' | 'meeting_notes' | 'learning' | 'research' | 'planning' | 'retrospective' | 'standup' | 'technical_note' | 'development_note' | 'enhancement' | 'milestone' | 'flag' | 'system_integration_test' | 'test_entry' | 'other';
+type EntryType = 'personal_reflection' | 'project_decision' | 'technical_achievement' | 'bug_fix' | 'feature_implementation' | 'code_review' | 'meeting_notes' | 'learning' | 'research' | 'planning' | 'retrospective' | 'standup' | 'technical_note' | 'development_note' | 'enhancement' | 'milestone' | 'flag' | 'system_integration_test' | 'test_entry' | 'plan_draft' | 'adversarial_review' | 'plan_refinement' | 'copilot_validation' | 'other';
 /**
  * Significance types for important entries
  */

package/dist/index.js

@@ -1,5 +1,5 @@
-export { VERSION, createServer } from './chunk-DFQG7UR5.js';
-export { META_GROUPS, TOOL_GROUPS, calculateTokenSavings, filterTools, getAllToolNames, getFilterSummary, getToolFilterFromEnv, getToolGroup, isToolEnabled, logger, parseToolFilter } from './chunk-SYTB5YNH.js';
+export { VERSION, createServer } from './chunk-QCQPAF4I.js';
+export { META_GROUPS, TOOL_GROUPS, calculateTokenSavings, filterTools, getAllToolNames, getFilterSummary, getToolFilterFromEnv, getToolGroup, isToolEnabled, logger, parseToolFilter } from './chunk-ARLYSFSI.js';
 
 // src/types/index.ts
 var DEFAULT_CONFIG = {

package/dist/tools-P4VGG4FH.js

@@ -0,0 +1 @@
+export { callTool, getTools } from './chunk-ARLYSFSI.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "memory-journal-mcp",
-    "version": "7.6.1",
+    "version": "7.7.0",
     "description": "Project context management for AI-assisted development - Persistent knowledge graphs and intelligent context recall across fragmented AI threads",
     "type": "module",
     "main": "dist/index.js",
@@ -98,6 +98,7 @@
         "minimatch": "10.2.5",
         "tar": "7.5.13",
         "tmp": "^0.2.5",
-        "vite": "^8.0.5"
+        "vite": "^8.0.5",
+        "ip-address": "10.2.0"
     }
 }

package/skills/README.md

@@ -40,6 +40,7 @@ The markdown body contains the full instructions the agent follows once the skil
 
 | Skill                  | Description                                                                                                           |
 | ---------------------- | --------------------------------------------------------------------------------------------------------------------- |
+| `adversarial-planner`  | Multi-pass adversarial planning — iterative plan drafting, structured critique, and Copilot validation                |
 | `autonomous-dev`       | Harness for autonomous software development — alignment gates, adversarial agents, Git workflows, and CI/CD pipelines |
 | `bun`                  | Master the Bun all-in-one toolkit — runtime, package manager, test runner, and bundler                                |
 | `docker`               | Production-grade Docker — multi-stage builds, security hardening, Compose v2, BuildKit, and CI/CD integration         |

package/skills/adversarial-planner/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: adversarial-planner
+description: |
+  Multi-pass adversarial planning and review skill that improves agent-generated
+  plans through structured critique stages. Combines an initial planning agent
+  (structure, logic, task sequencing) with an adversarial review agent
+  (performance, security, maintainability) and a final Copilot CLI validation
+  pass. Use when creating implementation plans, designing architecture, planning
+  roadmaps or milestones, or when the user says "plan this", "review my plan",
+  "adversarial review", or "multi-pass plan".
+---
+
+# Adversarial Planner
+
+A multi-pass planning and review system that produces high-quality plans by
+introducing structured adversarial critique stages. Plans pass through an
+iterative pipeline of drafting, review, refinement, and optional external
+validation — producing output optimized for correctness, performance, security,
+and maintainability.
+
+## When to Load
+
+Load this skill when any of these apply:
+
+- Creating an implementation plan for a new feature or architectural change
+- Designing multi-file refactors or system migrations
+- Planning project roadmaps, milestones, or sprint scopes
+- The user asks for an adversarial or multi-pass review of a plan
+- The user says "plan this", "review my plan", "critique this plan", or
+  "multi-pass plan"
+- You want to reduce confirmation bias in your own planning output
+
+## Agent Roles
+
+This skill operates with two distinct mental models. You are both agents — you
+switch perspectives at phase boundaries.
+
+### Agent A — The Planner
+
+**Mandate:** Produce a comprehensive, well-structured plan.
+
+- Gather requirements from user request, code context, and prior work
+- Structure the plan with clear scope, file changes, task ordering, and risk
+  assessment
+- Optimize for completeness and logical sequencing
+- Reference prior planning sessions via journal search before starting
+
+### Agent B — The Adversarial Reviewer
+
+**Mandate:** Find every weakness the Planner missed.
+
+- Switch to a skeptical senior reviewer mindset
+- Challenge assumptions, flag gaps, and identify risks
+- Score findings across weighted review dimensions (see protocol reference)
+- Provide concrete, actionable remediation suggestions — not vague concerns
+
+The reason for explicit role separation is that it counteracts the natural
+tendency to defend your own output. By formally switching perspective, you
+engage different evaluation criteria than the ones that guided the draft.
+
+## The Multi-Pass Protocol
+
+The protocol runs in 4 phases. Each phase produces a journaled artifact.
+
+| Phase                 | Agent        | Output                                 | Entry Type           | Tags                                |
+| --------------------- | ------------ | -------------------------------------- | -------------------- | ----------------------------------- |
+| 1. Plan Draft         | A (Planner)  | Structured plan document               | `plan_draft`         | `adversarial-planner`, `plan-draft` |
+| 2. Adversarial Review | B (Reviewer) | Critique table with severity ratings   | `adversarial_review` | `adversarial-planner`, `review`     |
+| 3. Plan Refinement    | A (Planner)  | Refined plan with disposition notes    | `plan_refinement`    | `adversarial-planner`, `refinement` |
+| 4. Copilot Validation | External     | Independent architecture/security pass | `copilot_validation` | `adversarial-planner`, `copilot`    |
+
+For the full protocol with review dimensions, scoring weights, and output
+templates, read [references/multi-pass-protocol.md](references/multi-pass-protocol.md).
+
+## Copilot Integration
+
+Phase 4 triggers an independent validation pass using the GitHub Copilot CLI.
+This provides a fundamentally different model's perspective on the plan,
+reducing confirmation bias that persists even after adversarial self-review.
+
+For Copilot-specific prompt templates and integration details, read
+[references/copilot-integration.md](references/copilot-integration.md).
+
+**Prerequisites:** The `github-copilot-cli` skill must be available for CLI
+setup and authentication. The `copilot-audit` workflow in `github-commander`
+handles full repo audits — this skill focuses on plan-specific review.
+
+## Feedback Loop & Documentation
+
+Every phase creates a journal entry with structured tags and entry types. This
+builds a searchable audit trail that informs future planning sessions.
+
+For journal templates, tag conventions, cross-session learning patterns, and
+retrospective templates, read
+[references/feedback-loop.md](references/feedback-loop.md).
+
+## Configuration
+
+| Variable             | Default    | Description                                     |
+| -------------------- | ---------- | ----------------------------------------------- |
+| `MAX_PLAN_PASSES`    | `2`        | Maximum refinement cycles (phases 2–3 repeat)   |
+| `PLAN_REVIEW_DEPTH`  | `standard` | Review depth: `light`, `standard`, or `deep`    |
+| `COPILOT_VALIDATION` | `true`     | Enable/disable the Copilot CLI validation phase |
+
+### Review Depth Profiles
+
+- **Light**: Focus on correctness and security only. Best for small, low-risk
+  changes.
+- **Standard**: Full 5-dimension review. Default for most planning tasks.
+- **Deep**: Extended review with additional focus on long-term maintainability,
+  API surface design, and migration safety. Use for architectural decisions.
+
+## Synergies
+
+| Skill/Workflow                   | Relationship                                                                                                                                          |
+| -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `autonomous-dev`                 | The Generator/Evaluator pipeline in `autonomous-dev` applies at the code level; this skill applies the same adversarial pattern at the planning level |
+| `github-copilot-cli`             | Provides the CLI setup and auth required for Phase 4                                                                                                  |
+| `github-commander/copilot-audit` | Full repo/PR audit; this skill uses Copilot for plan-specific review instead                                                                          |
+| `skill-builder`                  | Use to refine this skill's instructions based on observed agent behavior                                                                              |

package/skills/adversarial-planner/references/copilot-integration.md

@@ -0,0 +1,98 @@
+# Copilot Integration
+
+Reference for Phase 4 of the adversarial planning protocol — the independent
+external validation pass using the GitHub Copilot CLI.
+
+## Why Copilot?
+
+After self-adversarial review (Phases 2–3), confirmation bias can still persist
+because the same model produced both the plan and the critique. The Copilot CLI
+invokes a fundamentally different model with a separate context window, catching
+blind spots that internal review misses.
+
+## Prerequisites
+
+1. **Copilot CLI installed**: `npm list -g @github/copilot`
+2. **Authenticated**: `copilot auth` (requires browser approval)
+3. **Skill dependency**: The `github-copilot-cli` skill documents setup details
+
+If Copilot CLI is not available, skip Phase 4 gracefully and note the skip in
+the journal entry.
+
+## Plan-Specific Prompt Templates
+
+These prompts differ from the full codebase/PR audit prompts in
+`github-commander/workflows/copilot-audit.md` — they focus on architectural
+decisions rather than code diffs.
+
+### Architecture Review
+
+```bash
+echo "You are a senior systems architect. Review this implementation plan for a software project. Focus on:
+1. Architectural soundness — are the proposed abstractions appropriate?
+2. Security gaps — are there missing auth checks, injection vectors, or data boundary issues?
+3. Performance risks — will this scale? Are there N+1 queries or hot-path allocations?
+4. Missing considerations — what did the planner forget?
+5. Task ordering — are dependencies correctly sequenced?
+
+Here is the plan:
+
+$(cat plan.md)
+
+Output a Markdown table of findings with columns: #, Category, Severity (Critical/Moderate/Low), Finding, Suggestion." | copilot
+```
+
+### Roadmap/Milestone Review
+
+```bash
+echo "You are a technical program manager reviewing a project roadmap. Evaluate:
+1. Scope creep — are the milestones focused and achievable?
+2. Risk distribution — are high-risk items front-loaded for early feedback?
+3. Dependency chains — are there single points of failure in the timeline?
+4. Resource assumptions — are the estimates realistic?
+5. Missing milestones — what validation checkpoints are missing?
+
+Here is the roadmap:
+
+$(cat roadmap.md)
+
+Output a structured assessment with recommendations." | copilot
+```
+
+### Targeted Security Review
+
+For plans that touch authentication, data access, or external integrations:
+
+```bash
+echo "You are a security engineer. This implementation plan proposes changes to a system. Review it exclusively for security implications:
+1. New attack surfaces introduced
+2. Auth/authz gaps
+3. Data validation boundaries
+4. Secret management
+5. Supply chain risks from new dependencies
+
+Plan:
+
+$(cat plan.md)
+
+List each finding with severity and a concrete mitigation." | copilot
+```
+
+## Parsing Copilot Output
+
+Copilot returns unstructured Markdown. To integrate findings into the protocol:
+
+1. **Extract findings** — parse the Markdown for tables or numbered lists
+2. **Map to dimensions** — classify each finding against the 5 review dimensions
+   (Correctness, Security, Performance, Maintainability, Completeness)
+3. **Deduplicate** — compare against Phase 2 findings; skip items already
+   addressed in the refinement
+4. **Disposition** — apply the same Accept/Reject/Modify framework from Phase 3
+
+## Cross-References
+
+- **`github-copilot-cli` skill** — CLI installation, authentication, and
+  non-interactive piping patterns
+- **`github-commander/workflows/copilot-audit.md`** — Full repo and PR-level
+  audits; use that workflow for post-implementation validation rather than
+  plan review

package/skills/adversarial-planner/references/feedback-loop.md

@@ -0,0 +1,148 @@
+# Feedback Loop & Documentation
+
+Reference for journaling, cross-session learning, and retrospective patterns
+used throughout the adversarial planning protocol.
+
+## Journal Entry Templates
+
+Each phase of the protocol creates a journal entry using `create_entry`. The
+structured entry types and tags enable precise retrieval in future sessions.
+
+### Phase 1 — Plan Draft
+
+```
+create_entry({
+  content: "# Plan Draft: [Title]\n\n[full plan content]",
+  entry_type: "plan_draft",
+  tags: ["adversarial-planner", "plan-draft"],
+  issue_number: <GitHub issue if applicable>,
+  project_number: <project number if applicable>
+})
+```
+
+### Phase 2 — Adversarial Review
+
+```
+create_entry({
+  content: "# Adversarial Review: [Title]\n\nOverall Score: X/5.0\n\n[critique table and scores]",
+  entry_type: "adversarial_review",
+  tags: ["adversarial-planner", "review"],
+  issue_number: <same issue>
+})
+```
+
+### Phase 3 — Plan Refinement
+
+```
+create_entry({
+  content: "# Plan Refinement: [Title]\n\n[disposition table + updated sections]",
+  entry_type: "plan_refinement",
+  tags: ["adversarial-planner", "refinement"],
+  issue_number: <same issue>
+})
+```
+
+### Phase 4 — Copilot Validation
+
+```
+create_entry({
+  content: "# Copilot Validation: [Title]\n\n[copilot findings + final dispositions]",
+  entry_type: "copilot_validation",
+  tags: ["adversarial-planner", "copilot"],
+  issue_number: <same issue>
+})
+```
+
+## Linking Entries
+
+Connect planning entries to each other and to related work using relationships:
+
+```
+link_entries({
+  from_entry_id: <review_entry_id>,
+  to_entry_id: <draft_entry_id>,
+  relationship_type: "references",
+  description: "Adversarial review of plan draft"
+})
+
+link_entries({
+  from_entry_id: <refinement_entry_id>,
+  to_entry_id: <review_entry_id>,
+  relationship_type: "evolves_from",
+  description: "Refined plan based on adversarial review findings"
+})
+
+link_entries({
+  from_entry_id: <implementation_entry_id>,
+  to_entry_id: <refinement_entry_id>,
+  relationship_type: "implements",
+  description: "Implementation of approved adversarial plan"
+})
+```
+
+## Cross-Session Learning
+
+Before starting a new plan, search for prior planning sessions to avoid
+repeating past mistakes and to reuse successful patterns.
+
+### Find Prior Plans in the Same Domain
+
+```
+search_entries({
+  query: "<feature area or component name>",
+  entry_type: "plan_draft",
+  tags: ["adversarial-planner"]
+})
+```
+
+### Find Recurring Review Findings
+
+If the same critique comes up repeatedly across plans, it signals a systemic
+pattern worth addressing at the architecture level:
+
+```
+search_entries({
+  query: "<recurring issue, e.g., 'missing auth check'>",
+  entry_type: "adversarial_review",
+  tags: ["adversarial-planner", "review"]
+})
+```
+
+### Find Plans for a Specific Issue
+
+```
+search_entries({
+  query: "plan",
+  issue_number: <issue_number>,
+  tags: ["adversarial-planner"]
+})
+```
+
+## Session Retrospective
+
+After completing a full planning cycle (all 4 phases), create a retrospective
+entry summarizing key insights from both agents and Copilot. This is the
+primary mechanism for building institutional knowledge about planning quality.
+
+### Retrospective Template
+
+```
+create_entry({
+  content: "# Adversarial Planning Retrospective: [Title]\n\n## Key Insights\n- [What the planner missed that the reviewer caught]\n- [What Copilot caught that internal review missed]\n- [Patterns worth institutionalizing]\n\n## Metrics\n- Initial plan score: X/5.0\n- Final plan score: Y/5.0\n- Refinement passes: N\n- Critical findings addressed: M\n\n## Process Improvements\n- [Adjustments for future planning cycles]",
+  entry_type: "retrospective",
+  tags: ["adversarial-planner", "retrospective", "session-summary"],
+  project_number: <project number>
+})
+```
+
+## Tag Convention
+
+| Tag                   | Purpose                                        |
+| --------------------- | ---------------------------------------------- |
+| `adversarial-planner` | All entries from this skill (primary filter)   |
+| `plan-draft`          | Phase 1 output                                 |
+| `review`              | Phase 2 output                                 |
+| `refinement`          | Phase 3 output                                 |
+| `copilot`             | Phase 4 output                                 |
+| `retrospective`       | Post-cycle summary                             |
+| `session-summary`     | Enables retrieval via session summary searches |

package/skills/adversarial-planner/references/multi-pass-protocol.md

@@ -0,0 +1,225 @@
+# Multi-Pass Protocol
+
+Detailed reference for the 4-phase adversarial planning workflow. Read this
+when executing the protocol for the full review dimensions, scoring system, and
+output templates.
+
+## Phase 1 — Initial Planning (Agent A: Planner)
+
+### Inputs
+
+Before drafting, gather context from these sources:
+
+1. **User request** — the stated requirements, constraints, and preferences
+2. **Codebase context** — existing architecture, patterns, and conventions
+3. **Prior plans** — search the journal for related planning entries:
+   ```
+   search_entries({
+     query: "<feature area>",
+     entry_type: "plan_draft",
+     tags: ["adversarial-planner"]
+   })
+   ```
+4. **Linked issues/PRs** — any GitHub issues or PRs referenced in the request
+
+### Draft Structure
+
+Produce a Markdown plan document with these sections:
+
+```markdown
+# [Feature/Change Title]
+
+## Scope
+
+What is included and explicitly excluded.
+
+## Context
+
+Background, motivation, and dependencies on existing systems.
+
+## Proposed Changes
+
+Group by component. For each file:
+
+- What changes and why
+- New dependencies introduced
+- Breaking changes (if any)
+
+## Task Ordering
+
+Numbered sequence with dependencies noted.
+Which tasks can be parallelized.
+
+## Risk Assessment
+
+| Risk | Likelihood | Impact | Mitigation |
+| ---- | ---------- | ------ | ---------- |
+
+## Open Questions
+
+Anything requiring user input before proceeding.
+```
+
+### Journal
+
+```
+create_entry({
+  content: "<full plan draft>",
+  entry_type: "plan_draft",
+  tags: ["adversarial-planner", "plan-draft"],
+  issue_number: <if applicable>,
+  project_number: <if applicable>
+})
+```
+
+## Phase 2 — Adversarial Review (Agent B: Reviewer)
+
+Switch mental models. You are now a skeptical senior reviewer whose job is to
+find every weakness in the plan. Do not defend the Planner's decisions — your
+job is to break them.
+
+### Review Dimensions
+
+Score each dimension on a 1–5 scale. Dimensions have different weights
+reflecting their relative importance:
+
+| Dimension           | Weight | Focus Areas                                                                                                  |
+| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------ |
+| **Correctness**     | 3      | Logic errors, edge cases, race conditions, error handling gaps, incorrect assumptions about existing APIs    |
+| **Security**        | 3      | Injection vectors, auth/authz gaps, data boundary validation, secret handling, input sanitization            |
+| **Performance**     | 2      | Algorithmic complexity, unnecessary allocations, N+1 queries, missing caching opportunities, hot-path impact |
+| **Maintainability** | 2      | Coupling, cohesion, single-responsibility violations, naming clarity, testability, documentation debt        |
+| **Completeness**    | 1      | Missing tests, missing docs, migration gaps, rollback strategy, monitoring/observability                     |
+
+### Depth Profiles
+
+The `PLAN_REVIEW_DEPTH` configuration controls which dimensions receive full
+scrutiny:
+
+- **Light**: Correctness + Security only (weights 3+3)
+- **Standard**: All 5 dimensions at stated weights
+- **Deep**: All 5 dimensions + extended analysis:
+  - API surface backward compatibility
+  - Long-term migration path (will this need to be redone in 6 months?)
+  - Cross-project impact (does this affect other repos in the ecosystem?)
+
+### Critique Output Format
+
+```markdown
+## Adversarial Review — [Feature/Change Title]
+
+**Overall Score:** [weighted average] / 5.0
+
+### Findings
+
+| #   | Dimension   | Severity | Finding                             | Remediation                                       |
+| --- | ----------- | -------- | ----------------------------------- | ------------------------------------------------- |
+| 1   | Security    | Critical | API endpoint lacks auth middleware  | Add scope check using existing hasScope() pattern |
+| 2   | Correctness | Moderate | Race condition in concurrent writes | Use DB transaction wrapping                       |
+| 3   | Performance | Low      | Unnecessary full-table scan         | Add index on lookup column                        |
+
+### Dimension Scores
+
+| Dimension       | Score | Weight | Weighted         |
+| --------------- | ----- | ------ | ---------------- |
+| Correctness     | 4     | 3      | 12               |
+| Security        | 2     | 3      | 6                |
+| Performance     | 4     | 2      | 8                |
+| Maintainability | 3     | 2      | 6                |
+| Completeness    | 4     | 1      | 4                |
+| **Total**       |       | **11** | **36/55 = 3.27** |
+
+### Blocking Issues
+
+List any findings that MUST be addressed before the plan can proceed.
+```
+
+### Journal
+
+```
+create_entry({
+  content: "<full critique>",
+  entry_type: "adversarial_review",
+  tags: ["adversarial-planner", "review"],
+  issue_number: <if applicable>
+})
+```
+
+## Phase 3 — Plan Refinement (Agent A: Planner)
+
+Switch back to the Planner role. Address every finding from the adversarial
+review with an explicit disposition:
+
+### Disposition Table
+
+For each finding, record one of:
+
+| Disposition | Meaning                                                             |
+| ----------- | ------------------------------------------------------------------- |
+| **Accept**  | Incorporate the suggestion into the refined plan                    |
+| **Reject**  | Explain why the finding does not apply or is not worth addressing   |
+| **Modify**  | Accept the spirit of the finding but implement a different solution |
+
+### Refined Plan Output
+
+Produce the refined plan as a delta against the original:
+
+```markdown
+## Plan Refinement — [Feature/Change Title]
+
+### Disposition Summary
+
+| #   | Finding         | Disposition | Rationale                                         |
+| --- | --------------- | ----------- | ------------------------------------------------- |
+| 1   | API lacks auth  | Accept      | Added scope check to proposed changes             |
+| 2   | Race condition  | Modify      | Using optimistic locking instead of transactions  |
+| 3   | Full-table scan | Reject      | Table has <100 rows, index overhead not justified |
+
+### Updated Sections
+
+[Only include sections that changed, with clear diff annotations]
+```
+
+### Iteration Control
+
+After refinement, check: has `MAX_PLAN_PASSES` been reached?
+
+- **No** → return to Phase 2 for another adversarial review of the refined plan
+- **Yes** → proceed to Phase 4
+
+The default of 2 passes means: 1 initial review + 1 review of the refinement.
+For most plans this is sufficient. Increase for high-stakes architectural
+decisions.
+
+### Journal
+
+```
+create_entry({
+  content: "<refinement with dispositions>",
+  entry_type: "plan_refinement",
+  tags: ["adversarial-planner", "refinement"],
+  issue_number: <if applicable>
+})
+```
+
+## Phase 4 — Copilot Validation (External)
+
+If `COPILOT_VALIDATION` is enabled (default: `true`), invoke the Copilot CLI
+for an independent review of the finalized plan.
+
+See [copilot-integration.md](copilot-integration.md) for prompt templates and
+parsing guidance.
+
+After the Copilot pass, any new findings follow the same disposition process
+from Phase 3. The final plan is then presented to the user for approval.
+
+### Journal
+
+```
+create_entry({
+  content: "<copilot findings + final dispositions>",
+  entry_type: "copilot_validation",
+  tags: ["adversarial-planner", "copilot"],
+  issue_number: <if applicable>
+})
+```

package/skills/package.json

@@ -11,6 +11,7 @@
         "bin/",
         "README.md",
         "autonomous-dev/",
+        "adversarial-planner/",
         "bun/",
         "docker/",
         "github-actions/",

package/dist/tools-JQPK5JFS.js

@@ -1 +0,0 @@
-export { callTool, getTools } from './chunk-SYTB5YNH.js';