trinity-method-sdk 2.2.0 → 2.2.2

package/dist/cli/commands/deploy/gitignore.js

@@ -18,13 +18,8 @@ export async function updateGitignore(spinner) {
         if (await fs.pathExists(gitignorePath)) {
             gitignoreContent = await fs.readFile(gitignorePath, 'utf8');
         }
-        // Trinity files to ignore (archive and templates are ephemeral/generated)
-        const trinityIgnores = [
-            '',
-            '# Trinity Method SDK',
-            '.claude/trinity/archive/',
-            '.claude/trinity/templates/',
-        ];
+        // Trinity files to ignore (entire .claude/ directory and all CLAUDE.md files)
+        const trinityIgnores = ['', '# Trinity Method SDK', '.claude/', '*CLAUDE.md'];
         // Check if Trinity section already exists
         if (!gitignoreContent.includes('# Trinity Method SDK')) {
             // Append Trinity ignores

package/dist/cli/commands/update/index.js

@@ -10,6 +10,7 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { runUpdatePreflightChecks } from './pre-flight.js';
 import { detectInstalledSDKVersion } from './version.js';
+import { detectLegacyDeployment, migrateLegacyDeployment, updateGitignoreForMigration, } from './migration.js';
 import { createUpdateBackup, restoreUserContent, rollbackFromBackup, cleanupBackup, } from './backup.js';
 import { updateAgents } from './agents.js';
 import { updateCommands } from './commands.js';
@@ -34,10 +35,23 @@ export async function update(options) {
         knowledgeBaseUpdated: 0,
         commandsUpdated: 0,
         filesUpdated: 0,
+        legacyMigrated: false,
+        gitignoreUpdated: false,
     };
     try {
         // STEP 1: Pre-flight checks
-        await runUpdatePreflightChecks(spinner);
+        const preflight = await runUpdatePreflightChecks(spinner);
+        // STEP 1.5: Legacy migration (pre-2.2.0 trinity/ → .claude/trinity/)
+        if (preflight.needsLegacyMigration) {
+            const legacyInfo = await detectLegacyDeployment(spinner);
+            if (legacyInfo.isLegacy) {
+                await migrateLegacyDeployment(spinner);
+                stats.legacyMigrated = true;
+            }
+        }
+        // STEP 1.7: Update .gitignore patterns
+        const gitignoreChanged = await updateGitignoreForMigration(spinner);
+        stats.gitignoreUpdated = gitignoreChanged;
         // STEP 2: Version check
         const versionInfo = await detectInstalledSDKVersion(spinner);
         if (versionInfo.isUpToDate && !options.force) {

package/dist/cli/commands/update/migration.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Update Migration Module
+ * Handles legacy deployment detection and migration from pre-2.2.0 structure
+ * @module cli/commands/update/migration
+ */
+import { Ora } from 'ora';
+export interface LegacyInfo {
+    isLegacy: boolean;
+    legacyVersion: string | null;
+}
+/**
+ * Detect if the project has a legacy (pre-2.2.0) Trinity deployment
+ * Legacy deployments use `trinity/` at root instead of `.claude/trinity/`
+ * @param spinner - ora spinner instance for status display
+ * @returns Legacy deployment info
+ */
+export declare function detectLegacyDeployment(spinner: Ora): Promise<LegacyInfo>;
+/**
+ * Migrate legacy Trinity deployment from `trinity/` to `.claude/trinity/`
+ * Preserves user-managed knowledge base files during migration
+ * @param spinner - ora spinner instance for status display
+ */
+export declare function migrateLegacyDeployment(spinner: Ora): Promise<void>;
+/**
+ * Update .gitignore to replace old Trinity patterns with current ones
+ * Safe to run on any deployment — idempotent
+ * @param spinner - ora spinner instance for status display
+ * @returns True if gitignore was updated
+ */
+export declare function updateGitignoreForMigration(spinner: Ora): Promise<boolean>;
+//# sourceMappingURL=migration.d.ts.map

package/dist/cli/commands/update/migration.js

@@ -0,0 +1,132 @@
+/**
+ * Update Migration Module
+ * Handles legacy deployment detection and migration from pre-2.2.0 structure
+ * @module cli/commands/update/migration
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { validatePath } from '../../utils/validate-path.js';
+/** Old gitignore patterns from previous deployments */
+const OLD_GITIGNORE_PATTERNS = [
+    'trinity/',
+    'TRINITY.md',
+    '.claude/trinity/archive/',
+    '.claude/trinity/templates/',
+];
+/** Current gitignore patterns */
+const CURRENT_GITIGNORE_PATTERNS = ['.claude/', '*CLAUDE.md'];
+/**
+ * Detect if the project has a legacy (pre-2.2.0) Trinity deployment
+ * Legacy deployments use `trinity/` at root instead of `.claude/trinity/`
+ * @param spinner - ora spinner instance for status display
+ * @returns Legacy deployment info
+ */
+export async function detectLegacyDeployment(spinner) {
+    spinner.start('Checking for legacy deployment...');
+    const hasLegacyDir = await fs.pathExists('trinity');
+    const hasLegacyVersion = await fs.pathExists('trinity/VERSION');
+    if (!hasLegacyDir) {
+        spinner.info('No legacy deployment detected');
+        return { isLegacy: false, legacyVersion: null };
+    }
+    let legacyVersion = null;
+    if (hasLegacyVersion) {
+        legacyVersion = (await fs.readFile('trinity/VERSION', 'utf8')).trim();
+    }
+    spinner.warn(`Legacy deployment detected (v${legacyVersion || 'unknown'})`);
+    return { isLegacy: true, legacyVersion };
+}
+/**
+ * Migrate legacy Trinity deployment from `trinity/` to `.claude/trinity/`
+ * Preserves user-managed knowledge base files during migration
+ * @param spinner - ora spinner instance for status display
+ */
+export async function migrateLegacyDeployment(spinner) {
+    spinner.start('Migrating legacy deployment to .claude/trinity/...');
+    // Create new directory structure
+    await fs.ensureDir('.claude/trinity');
+    await fs.ensureDir('.claude/agents/leadership');
+    await fs.ensureDir('.claude/agents/deployment');
+    await fs.ensureDir('.claude/agents/audit');
+    await fs.ensureDir('.claude/agents/planning');
+    await fs.ensureDir('.claude/agents/aj-team');
+    await fs.ensureDir('.claude/commands');
+    // Move trinity/ contents to .claude/trinity/
+    const trinityContents = await fs.readdir('trinity');
+    for (const item of trinityContents) {
+        const srcPath = path.join('trinity', item);
+        const destPath = path.join('.claude/trinity', item);
+        // Don't overwrite if destination already exists (prefer new structure)
+        if (!(await fs.pathExists(destPath))) {
+            await fs.copy(srcPath, destPath);
+        }
+    }
+    // Remove old trinity/ directory
+    await fs.remove('trinity');
+    spinner.succeed('Legacy deployment migrated to .claude/trinity/');
+}
+/**
+ * Update .gitignore to replace old Trinity patterns with current ones
+ * Safe to run on any deployment — idempotent
+ * @param spinner - ora spinner instance for status display
+ * @returns True if gitignore was updated
+ */
+export async function updateGitignoreForMigration(spinner) {
+    spinner.start('Updating .gitignore patterns...');
+    const gitignorePath = '.gitignore';
+    if (!(await fs.pathExists(gitignorePath))) {
+        spinner.info('No .gitignore found, skipping');
+        return false;
+    }
+    let content = await fs.readFile(gitignorePath, 'utf8');
+    const originalContent = content;
+    if (content.includes('# Trinity Method SDK')) {
+        // Remove the existing Trinity section entirely
+        const lines = content.split('\n');
+        const filteredLines = [];
+        let inTrinitySection = false;
+        for (const line of lines) {
+            if (line.trim() === '# Trinity Method SDK') {
+                inTrinitySection = true;
+                continue;
+            }
+            // End of Trinity section: next comment or blank line after non-Trinity content
+            if (inTrinitySection) {
+                const trimmed = line.trim();
+                // Still in Trinity section if line is empty, or matches known patterns
+                if (trimmed === '' ||
+                    trimmed === 'trinity/' ||
+                    trimmed === '*CLAUDE.md' ||
+                    trimmed === 'TRINITY.md' ||
+                    trimmed === '.claude/' ||
+                    trimmed === '.claude/trinity/archive/' ||
+                    trimmed === '.claude/trinity/templates/') {
+                    continue;
+                }
+                // Non-Trinity line — we've left the section
+                inTrinitySection = false;
+            }
+            filteredLines.push(line);
+        }
+        content = filteredLines.join('\n');
+    }
+    // Remove any standalone old patterns that might exist outside the section
+    for (const pattern of OLD_GITIGNORE_PATTERNS) {
+        const regex = new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'gm');
+        content = content.replace(regex, '');
+    }
+    // Clean up multiple blank lines
+    content = content.replace(/\n{3,}/g, '\n\n').trim();
+    // Append current Trinity section
+    const trinitySection = ['', '# Trinity Method SDK', ...CURRENT_GITIGNORE_PATTERNS].join('\n');
+    content = `${content}\n${trinitySection}\n`;
+    if (content === originalContent) {
+        spinner.info('.gitignore already up to date');
+        return false;
+    }
+    const validatedPath = validatePath(gitignorePath);
+    await fs.writeFile(validatedPath, content);
+    spinner.succeed('.gitignore patterns updated');
+    return true;
+}
+//# sourceMappingURL=migration.js.map

package/dist/cli/commands/update/pre-flight.d.ts

@@ -4,10 +4,15 @@
  * @module cli/commands/update/pre-flight
  */
 import { Ora } from 'ora';
+export interface PreflightResult {
+    needsLegacyMigration: boolean;
+}
 /**
  * Run pre-flight checks to ensure Trinity Method is deployed
+ * Detects both current (.claude/trinity/) and legacy (trinity/) layouts
  * @param spinner - ora spinner instance for status display
- * @throws {UpdateError} If pre-flight checks fail
+ * @returns Pre-flight result with migration flags
+ * @throws {UpdateError} If no Trinity deployment found at all
  */
-export declare function runUpdatePreflightChecks(spinner: Ora): Promise<void>;
+export declare function runUpdatePreflightChecks(spinner: Ora): Promise<PreflightResult>;
 //# sourceMappingURL=pre-flight.d.ts.map

package/dist/cli/commands/update/pre-flight.js

@@ -7,31 +7,32 @@ import fs from 'fs-extra';
 import { UpdateError } from '../../utils/error-classes.js';
 /**
  * Run pre-flight checks to ensure Trinity Method is deployed
+ * Detects both current (.claude/trinity/) and legacy (trinity/) layouts
  * @param spinner - ora spinner instance for status display
- * @throws {UpdateError} If pre-flight checks fail
+ * @returns Pre-flight result with migration flags
+ * @throws {UpdateError} If no Trinity deployment found at all
  */
 export async function runUpdatePreflightChecks(spinner) {
     spinner.start('Running pre-flight checks...');
-    // Check .claude directory exists
     const claudeExists = await fs.pathExists('.claude');
-    if (!claudeExists) {
-        spinner.fail('.claude directory not found');
-        const { displayInfo } = await import('../../utils/errors.js');
-        displayInfo('Use: trinity deploy to install');
-        throw new UpdateError('.claude directory not found', {
-            reason: 'claude_directory_missing',
-        });
-    }
-    // Check .claude/trinity directory exists
     const trinityExists = await fs.pathExists('.claude/trinity');
-    if (!trinityExists) {
-        spinner.fail('Trinity Method not deployed');
-        const { displayInfo } = await import('../../utils/errors.js');
-        displayInfo('Trinity deployment appears incomplete');
-        throw new UpdateError('Trinity Method not deployed in this project', {
-            reason: 'trinity_directory_missing',
-        });
+    const legacyExists = await fs.pathExists('trinity');
+    // Current structure found — no migration needed
+    if (claudeExists && trinityExists) {
+        spinner.succeed('Pre-flight checks passed');
+        return { needsLegacyMigration: false };
+    }
+    // Legacy structure found — migration needed
+    if (legacyExists) {
+        spinner.succeed('Pre-flight checks passed (legacy deployment detected)');
+        return { needsLegacyMigration: true };
     }
-    spinner.succeed('Pre-flight checks passed');
+    // Neither found — not deployed
+    spinner.fail('Trinity Method not deployed');
+    const { displayInfo } = await import('../../utils/errors.js');
+    displayInfo('Use: trinity deploy to install');
+    throw new UpdateError('Trinity Method not deployed in this project', {
+        reason: 'trinity_directory_missing',
+    });
 }
 //# sourceMappingURL=pre-flight.js.map

package/dist/cli/commands/update/summary.js

@@ -18,6 +18,12 @@ export function displayUpdateSummary(stats, oldVersion, newVersion) {
     console.log(chalk.white(`   Commands Updated: ${stats.commandsUpdated}`));
     console.log(chalk.white(`   Templates Updated: ${stats.templatesUpdated}`));
     console.log(chalk.white(`   Knowledge Base Updated: ${stats.knowledgeBaseUpdated}`));
+    if (stats.legacyMigrated) {
+        console.log(chalk.yellow(`   Legacy Migration: trinity/ → .claude/trinity/`));
+    }
+    if (stats.gitignoreUpdated) {
+        console.log(chalk.white(`   .gitignore: Updated`));
+    }
     console.log(chalk.white(`   Total Files Updated: ${stats.agentsUpdated + stats.commandsUpdated + stats.templatesUpdated + stats.knowledgeBaseUpdated}`));
     console.log('');
     console.log(chalk.gray(`   Version: ${oldVersion} → ${newVersion}\n`));

package/dist/cli/commands/update/types.d.ts

@@ -9,5 +9,7 @@ export interface UpdateStats {
     knowledgeBaseUpdated: number;
     commandsUpdated: number;
     filesUpdated: number;
+    legacyMigrated: boolean;
+    gitignoreUpdated: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/cli/commands/update/version.js

@@ -13,11 +13,13 @@ import { getPackageJsonPath } from '../../utils/get-sdk-path.js';
  */
 export async function detectInstalledSDKVersion(spinner) {
     spinner.start('Checking versions...');
-    // Read current version from trinity/VERSION
-    const versionPath = '.claude/trinity/VERSION';
+    // Read current version from .claude/trinity/VERSION (or legacy trinity/VERSION)
     let currentVersion = '0.0.0';
-    if (await fs.pathExists(versionPath)) {
-        currentVersion = (await fs.readFile(versionPath, 'utf8')).trim();
+    if (await fs.pathExists('.claude/trinity/VERSION')) {
+        currentVersion = (await fs.readFile('.claude/trinity/VERSION', 'utf8')).trim();
+    }
+    else if (await fs.pathExists('trinity/VERSION')) {
+        currentVersion = (await fs.readFile('trinity/VERSION', 'utf8')).trim();
     }
     // Read latest version from SDK package.json
     const sdkPkgPath = await getPackageJsonPath();

package/dist/templates/.claude/commands/session/trinity-end.md.template

@@ -17,17 +17,29 @@ End current Trinity Method session and prepare for commit.
 
    **STRICT ARCHIVING PROTOCOL:**
 
-   a. **Archive Completed Work Orders:**
+   a. **Archive Completed Work Orders from sessions/:**
       - Read all files from `.claude/trinity/sessions/` matching `WO-*.md`
       - Move each to `.claude/trinity/archive/work-orders/YYYY-MM-DD/`
       - These were moved to sessions/ after completion per work order template
 
-   b. **Archive Completed Investigations:**
+   b. **Archive Completed Work Orders from work-orders/:**
+      - Check `.claude/trinity/work-orders/` for any completed work orders
+      - Completed work orders have status marked as "COMPLETED" or "CLOSED"
+      - Move completed ones to `.claude/trinity/archive/work-orders/YYYY-MM-DD/`
+      - Leave active/in-progress work orders in place
+
+   c. **Archive Completed Investigations from sessions/:**
       - Read all files from `.claude/trinity/sessions/` matching `INV-*.md`
       - Move each to `.claude/trinity/archive/investigations/YYYY-MM-DD/`
       - These were moved to sessions/ after completion per investigation template
 
-   c. **Archive ALL Reports:**
+   d. **Archive Completed Investigations from investigations/:**
+      - Check `.claude/trinity/investigations/` for any completed investigations
+      - Move completed ones to `.claude/trinity/archive/investigations/YYYY-MM-DD/`
+      - Also check `.claude/trinity/investigations/plans/` and archive any completed investigation plans
+      - Leave active/in-progress investigations in place
+
+   e. **Archive ALL Reports:**
       - Move ALL files from `.claude/trinity/reports/` to `.claude/trinity/archive/reports/YYYY-MM-DD/`
       - This includes:
         - Implementation completion reports
@@ -36,15 +48,26 @@ End current Trinity Method session and prepare for commit.
         - Any other session reports
       - **NO EXCEPTIONS:** Every file in reports/ must be archived
 
-   d. **Archive Session Files:**
+   f. **Archive Plan Mode Files:**
+      - Move ALL files from `.claude/trinity/plans/` to `.claude/trinity/archive/sessions/YYYY-MM-DD/`
+      - These are created by Claude Code during plan mode sessions
+      - They are session artifacts and should be archived with session files
+
+   g. **Archive Session Files:**
       - Move ALL remaining files from `.claude/trinity/sessions/` to `.claude/trinity/archive/sessions/YYYY-MM-DD/`
       - Create session summary document in `.claude/trinity/archive/sessions/YYYY-MM-DD/SESSION-SUMMARY-{date}.md`
 
-   e. **Verify Clean Slate:**
+   h. **Organize Loose Archive Files:**
+      - Check each `.claude/trinity/archive/` subdirectory (work-orders/, investigations/, reports/, sessions/)
+      - If any files exist directly in a subdirectory (not inside a YYYY-MM-DD/ date folder), move them into the appropriate `YYYY-MM-DD/` folder based on their modification date
+      - This ensures all archived files are properly organized in date folders
+
+   i. **Verify Clean Slate:**
       - **CRITICAL:** After archiving, `.claude/trinity/sessions/` MUST be empty
       - **CRITICAL:** After archiving, `.claude/trinity/reports/` MUST be empty
+      - **CRITICAL:** After archiving, `.claude/trinity/plans/` MUST be empty
       - If any files remain, archive them or report error
-      - Next session MUST start with completely empty sessions/ and reports/ folders
+      - Next session MUST start with completely empty sessions/, reports/, and plans/ folders
 
    **Archive Structure:**
    ```
@@ -56,6 +79,7 @@ End current Trinity Method session and prepare for commit.
    ├── investigations/YYYY-MM-DD/
    │   ├── INV-001-*.md
    │   ├── INV-002-*.md
+   │   ├── INV-001-plan-*.md
    │   └── ...
    ├── reports/YYYY-MM-DD/
    │   ├── WO-001-IMPLEMENTATION-COMPLETE-*.md
@@ -64,6 +88,7 @@ End current Trinity Method session and prepare for commit.
    │   └── ...
    └── sessions/YYYY-MM-DD/
        ├── SESSION-SUMMARY-{date}.md
+       ├── [plan mode files]
        └── [any other session files]
    ```
 
@@ -71,8 +96,10 @@ End current Trinity Method session and prepare for commit.
    - Keep ONLY active/in-progress work orders in `.claude/trinity/work-orders/`
    - Keep ONLY active/in-progress investigations in `.claude/trinity/investigations/`
    - Do NOT archive incomplete work
-   - Completed work is identified by presence in `.claude/trinity/sessions/` folder
+   - Completed work may exist in both `sessions/` AND their source directories (`work-orders/`, `investigations/`)
+   - The `plans/` directory is created by Claude Code during plan mode — always archive all contents
    - All reports are archived regardless of status
+   - Loose files in archive subdirectories should be organized into YYYY-MM-DD date folders
 
 2. **ALY analyzes session events:**
    - Review all work completed during session
@@ -87,6 +114,8 @@ End current Trinity Method session and prepare for commit.
    - Verify .claude/trinity/investigations/ contains only active investigations
    - Verify .claude/trinity/reports/ is empty
    - Verify .claude/trinity/sessions/ is empty
+   - Verify .claude/trinity/plans/ is empty
+   - Verify all files in .claude/trinity/archive/ subdirectories are in YYYY-MM-DD date folders
    - Ready for next session
 
 4. **Git commit instructions:**

package/dist/templates/.claude/commands/utility/trinity-workorder.md.template

@@ -32,6 +32,23 @@ Examples: WO-042-jwt-refresh-implementation.md
 
 ---
 
+## Work Order Numbering
+
+**To determine the next WO number:**
+
+1. Scan `.claude/trinity/work-orders/` for files matching `WO-*.md`
+2. Scan `.claude/trinity/sessions/` for files matching `WO-*.md`
+3. From all matches in those two directories, extract the highest `XXX` number
+4. New WO number = highest + 1 (zero-padded to 3 digits)
+5. If NO work orders are found in either directory, start at `WO-001`
+
+**IMPORTANT:**
+- Do **NOT** scan `.claude/trinity/archive/` — archived WOs belong to past sessions
+- Do **NOT** scan any other directories
+- Each new session with no active or pending WOs starts fresh at WO-001
+
+---
+
 ## Direct Work Order Creation
 
 When `/trinity-workorder` is invoked, the agent will:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trinity-method-sdk",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Trinity Method SDK - Investigation-first development methodology for any project",
   "type": "module",
   "main": "dist/index.js",