filemayor 4.0.7 → 4.0.8

package/core/config.js

@@ -532,18 +532,78 @@ security:
 `;
 }
 
+/**
+ * Generate a PARA-method .filemayor.yml template.
+ * PARA (Projects, Areas, Resources, Archives) is a method by Tiago Forte;
+ * FileMayor automates it — this preset tunes the actionability sorter.
+ * @returns {string} YAML config template
+ */
+function generateParaTemplate() {
+    return `# ═══════════════════════════════════════════════════════════
+# FileMayor Configuration — PARA preset
+# PARA = Projects · Areas · Resources · Archives (method by Tiago Forte).
+# FileMayor automates it by sorting files on actionability signals.
+# Run:  filemayor para .        (preview the plan)
+#       filemayor apply         (execute, fully reversible)
+# ═══════════════════════════════════════════════════════════
+
+version: 1
+
+# ─── PARA Actionability Sorter ─────────────────────────────
+para:
+  # Files not modified in this many months are moved to Archives.
+  archiveAfterMonths: 12
+
+  # Files modified within this window count as active → Projects.
+  activeWithinMonths: 3
+
+  # Where files with no clear signal land: projects|areas|resources|archives
+  defaultBucket: resources
+
+  # Keep the top-level subfolder name as a grouping inside each bucket.
+  preserveSubfolders: true
+
+  # Bucket folder names (rename or localize freely).
+  folders:
+    projects: Projects
+    areas: Areas
+    resources: Resources
+    archives: Archives
+
+  # Folder/name words that signal an ongoing responsibility (Areas).
+  areaKeywords: [finance, finances, tax, taxes, invoice, invoices, receipt, insurance, health, medical, home, car, contract, contracts, legal, admin, hr, utilities]
+
+  # File categories that are reference material by nature (Resources).
+  resourceCategories: [books, fonts, design]
+
+  # Folder/name words that signal reference material (Resources).
+  resourceKeywords: [reference, template, templates, manual, manuals, docs, research, notes, inspiration, assets, library, guide, guides]
+
+  # Folder/name words that signal active efforts (Projects).
+  projectKeywords: [project, projects, client, launch, campaign, sprint, deliverable, proposal, draft]
+
+# ─── Security ──────────────────────────────────────────────
+security:
+  confirmDestructive: true
+  journalEnabled: true
+  journalPath: .filemayor-journal.json
+`;
+}
+
 /**
  * Create a config file in the specified directory
  * @param {string} dir - Directory to create config in
  * @param {string} filename - Config filename
+ * @param {string} preset - Template preset: 'default' | 'para'
  * @returns {string} Path to created file
  */
-function createConfigFile(dir = process.cwd(), filename = '.filemayor.yml') {
+function createConfigFile(dir = process.cwd(), filename = '.filemayor.yml', preset = 'default') {
     const configPath = path.join(dir, filename);
     if (fs.existsSync(configPath)) {
         throw new Error(`Config file already exists: ${configPath}`);
     }
-    fs.writeFileSync(configPath, generateTemplate(), 'utf8');
+    const template = preset === 'para' ? generateParaTemplate() : generateTemplate();
+    fs.writeFileSync(configPath, template, 'utf8');
     return configPath;
 }
 
@@ -558,5 +618,6 @@ module.exports = {
     expandVariables,
     parseSimpleYaml,
     generateTemplate,
+    generateParaTemplate,
     createConfigFile
 };

package/core/engine/para-engine.js

@@ -0,0 +1,370 @@
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR — PARA ENGINE
+ * Deterministic actionability sorter implementing Tiago Forte's PARA
+ * method (Projects · Areas · Resources · Archives).
+ *
+ * PARA organizes by *actionability*, not by file type. A pure semantic
+ * judgement (is this an active Project or an ongoing Area?) needs a
+ * human or an LLM — so this engine is deliberately honest: it sorts on
+ * the signals it can actually read (recency, category, folder names,
+ * project substrates) and labels every move with the reason it chose.
+ * Where it cannot tell, it says so (warnings) rather than guessing
+ * confidently. Semantic refinement is what the AI path is for.
+ *
+ * Output shape matches the Curative Plan consumed by ApplyEngine:
+ *   { narrative, confidence, warnings, plan: [{ source, destination,
+ *     reason, bucket }], summary }
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const path = require('path');
+const { scan } = require('../scanner');
+const { findNearestSubstrate } = require('../security');
+
+// ─── PARA Defaults ────────────────────────────────────────────────
+// Mirrors config.para in cli/core/config.js. Anything passed to the
+// constructor overrides these per-field.
+const DEFAULT_PARA = {
+    archiveAfterMonths: 12,   // not modified in ≥ this many months → Archives
+    activeWithinMonths: 3,    // modified within this window → Projects (active work)
+    defaultBucket: 'resources', // where files with no actionability signal land
+    preserveSubfolders: true, // keep the top-level subfolder name as a grouping
+    folders: {
+        projects: 'Projects',
+        areas: 'Areas',
+        resources: 'Resources',
+        archives: 'Archives',
+    },
+    // Ongoing responsibilities you maintain indefinitely (Areas).
+    areaKeywords: [
+        'finance', 'finances', 'financial', 'tax', 'taxes', 'invoice', 'invoices',
+        'receipt', 'receipts', 'banking', 'payroll', 'payslip', 'insurance',
+        'health', 'medical', 'fitness', 'home', 'house', 'car', 'vehicle',
+        'contract', 'contracts', 'legal', 'admin', 'hr', 'utilities', 'pet', 'pets',
+    ],
+    // File categories that are reference material by nature (Resources).
+    resourceCategories: ['books', 'fonts', 'design'],
+    // Folder names that signal reference/interest material (Resources).
+    resourceKeywords: [
+        'reference', 'references', 'template', 'templates', 'manual', 'manuals',
+        'docs', 'documentation', 'research', 'notes', 'inspiration', 'assets',
+        'library', 'resource', 'resources', 'guide', 'guides', 'cheatsheet',
+    ],
+    // Folder/name signals for active efforts with an end (Projects).
+    projectKeywords: [
+        'project', 'projects', 'client', 'clients', 'launch', 'campaign',
+        'sprint', 'deliverable', 'proposal', 'wip', 'draft', 'milestone',
+    ],
+};
+
+const MONTH_MS = 1000 * 60 * 60 * 24 * 30.44; // average month
+
+class PARAEngine {
+    /**
+     * @param {Object} paraConfig - Overrides for DEFAULT_PARA (typically config.para)
+     */
+    constructor(paraConfig = {}) {
+        this.config = {
+            ...DEFAULT_PARA,
+            ...paraConfig,
+            folders: { ...DEFAULT_PARA.folders, ...(paraConfig.folders || {}) },
+        };
+        // The four bucket folder names, lowercased, for idempotency checks.
+        this._bucketNames = new Set(
+            Object.values(this.config.folders).map(f => f.toLowerCase())
+        );
+    }
+
+    /**
+     * Generate a PARA reorganisation plan for a directory (read-only).
+     * @param {string} dirPath - Directory to organise
+     * @param {Object} [options]
+     * @param {number} [options.now] - Reference timestamp (ms) — injectable for tests
+     * @returns {Object} Curative-plan-shaped result
+     */
+    plan(dirPath, options = {}) {
+        const root = path.resolve(dirPath);
+        const now = options.now || Date.now();
+
+        const scanResult = scan(root, { ...(options.scanOptions || {}), includeDirectories: false });
+
+        const plan = [];
+        const counts = { projects: 0, areas: 0, resources: 0, archives: 0 };
+        const seenDest = new Set();
+        const movedSubstrates = new Set();
+        let noSignalCount = 0;
+        let alreadySorted = 0;
+
+        for (const file of scanResult.files) {
+            const rel = path.relative(root, file.path);
+            const segments = rel.split(path.sep);
+
+            // Idempotency: skip anything already living under a PARA bucket.
+            if (segments.length > 1 && this._bucketNames.has(segments[0].toLowerCase())) {
+                alreadySorted++;
+                continue;
+            }
+
+            // Project substrates (.git, package.json, .als, …) move as one
+            // atomic unit into Projects — never shredded file-by-file.
+            const substrate = findNearestSubstrate(file.path);
+            if (substrate) {
+                const substrateRoot = path.resolve(substrate);
+                // A substrate that IS the target dir can't be PARA-organised.
+                if (substrateRoot === root) continue;
+                if (movedSubstrates.has(substrateRoot)) continue;
+                movedSubstrates.add(substrateRoot);
+
+                const dest = this._dest(root, 'projects', [path.basename(substrateRoot)]);
+                plan.push({
+                    source: substrateRoot,
+                    destination: dest,
+                    bucket: 'projects',
+                    reason: `Active project (contains ${path.basename(substrate) === path.basename(substrateRoot) ? 'a project marker' : 'project files'}) — moved intact. COLLECTION_MOVE`,
+                });
+                counts.projects++;
+                continue;
+            }
+
+            const { bucket, reason, noSignal } = this._classify(file, rel, now);
+            if (noSignal) noSignalCount++;
+            counts[bucket]++;
+
+            // Preserve the top-level subfolder as a grouping inside the bucket.
+            const sub = (this.config.preserveSubfolders && segments.length > 1)
+                ? [segments[0]]
+                : [];
+            let dest = this._dest(root, bucket, [...sub, file.name]);
+
+            // Avoid two sources colliding on one destination within the plan.
+            if (seenDest.has(dest.toLowerCase())) {
+                const parsed = path.parse(dest);
+                dest = path.join(parsed.dir, `${parsed.name}_${counts[bucket]}${parsed.ext}`);
+            }
+            seenDest.add(dest.toLowerCase());
+
+            plan.push({ source: file.path, destination: dest, bucket, reason });
+        }
+
+        const warnings = [];
+        if (noSignalCount > 0) {
+            warnings.push(
+                `${noSignalCount} file(s) had no clear actionability signal and were placed in ` +
+                `${this.config.folders[this.config.defaultBucket]} for you to review.`
+            );
+        }
+        if (alreadySorted > 0) {
+            warnings.push(`${alreadySorted} file(s) were already inside a PARA folder and left untouched.`);
+        }
+
+        return {
+            mode: 'deterministic',
+            method: 'PARA',
+            narrative: this._narrative(counts, plan.length),
+            confidence: 100, // deterministic — every move is rule-derived
+            warnings,
+            plan,
+            summary: {
+                totalMoves: plan.length,
+                buckets: counts,
+                scanned: scanResult.files.length,
+            },
+        };
+    }
+
+    /**
+     * Create and populate the four PARA folders with teaching READMEs.
+     * Idempotent — existing folders/READMEs are left in place.
+     * @param {string} dirPath - Where to scaffold
+     * @returns {{ created: string[], folders: Object }}
+     */
+    scaffold(dirPath) {
+        const fs = require('fs');
+        const root = path.resolve(dirPath);
+        const created = [];
+
+        for (const key of ['projects', 'areas', 'resources', 'archives']) {
+            const folder = path.join(root, this.config.folders[key]);
+            if (!fs.existsSync(folder)) {
+                fs.mkdirSync(folder, { recursive: true });
+                created.push(folder);
+            }
+            const readme = path.join(folder, 'README.md');
+            if (!fs.existsSync(readme)) {
+                fs.writeFileSync(readme, PARA_READMES[key], 'utf8');
+                created.push(readme);
+            }
+        }
+
+        return { created, folders: this.config.folders };
+    }
+
+    // ─── Internals ────────────────────────────────────────────────
+
+    /**
+     * Decide a file's PARA bucket from the signals we can actually read.
+     *
+     * Order is deliberate: EXPLICIT INTENT first (file category and the
+     * folder names the user themselves chose), then INFERRED TIME signals
+     * as the fallback for loose, unfiled files. Rationale — if you already
+     * filed something under finances/ or templates/, honour that meaning
+     * regardless of age; don't fragment a maintained folder by date. The
+     * "stale → Archives" automation then targets exactly the loose junk
+     * where it's most valuable. Every branch states its reason.
+     */
+    _classify(file, rel, now) {
+        const hay = rel.toLowerCase();
+        const cat = file.category || 'other';
+        const ageMonths = this._ageMonths(file, now);
+
+        // ── Explicit intent ──────────────────────────────────────
+        // 1. Reference by nature — books, fonts, design assets.
+        if (this.config.resourceCategories.includes(cat)) {
+            return { bucket: 'resources', reason: `Reference material (${cat})` };
+        }
+
+        // 2. Ongoing responsibility — a maintained Area (finances/, health/…).
+        const areaHit = this._keywordHit(hay, this.config.areaKeywords);
+        if (areaHit) {
+            return { bucket: 'areas', reason: `Ongoing responsibility (matched "${areaHit}")` };
+        }
+
+        // 3. Reference by folder name (reference/, templates/, …).
+        const resourceHit = this._keywordHit(hay, this.config.resourceKeywords);
+        if (resourceHit) {
+            return { bucket: 'resources', reason: `Reference material (matched "${resourceHit}")` };
+        }
+
+        // 4. Explicit active-effort signal (client-*, *-launch, project/…).
+        const projectHit = this._keywordHit(hay, this.config.projectKeywords);
+        if (projectHit) {
+            return { bucket: 'projects', reason: `Active project (matched "${projectHit}")` };
+        }
+
+        // ── Inferred time signals (loose, unfiled files only) ─────
+        // 5. Inactive — not modified in a long time → Archives. The single
+        //    most automatable PARA decision, and the one humans avoid.
+        if (ageMonths !== null && ageMonths >= this.config.archiveAfterMonths) {
+            return { bucket: 'archives', reason: `Not modified in ${Math.round(ageMonths)} months` };
+        }
+
+        // 6. Recently active loose work → Projects.
+        if (ageMonths !== null && ageMonths <= this.config.activeWithinMonths) {
+            return { bucket: 'projects', reason: `Recently active (modified ${Math.round(ageMonths)} month(s) ago)` };
+        }
+
+        // 7. No clear actionability signal — honest fallback, flagged for review.
+        const fallback = this.config.defaultBucket;
+        return {
+            bucket: fallback,
+            reason: 'No clear actionability signal — placed here for review',
+            noSignal: true,
+        };
+    }
+
+    _ageMonths(file, now) {
+        const t = this._mtime(file);
+        if (t === null) return null;
+        return (now - t) / MONTH_MS;
+    }
+
+    _mtime(file) {
+        const m = file.modified || file.created;
+        if (!m) return null;
+        const t = (m instanceof Date) ? m.getTime() : new Date(m).getTime();
+        return Number.isFinite(t) ? t : null;
+    }
+
+    _keywordHit(haystack, keywords) {
+        for (const kw of keywords) {
+            // Word-ish boundary so "car" doesn't match "scary".
+            const re = new RegExp(`(^|[^a-z0-9])${escapeRe(kw)}([^a-z0-9]|$)`, 'i');
+            if (re.test(haystack)) return kw;
+        }
+        return null;
+    }
+
+    _dest(root, bucketKey, parts) {
+        return path.join(root, this.config.folders[bucketKey], ...parts);
+    }
+
+    _narrative(counts, total) {
+        if (total === 0) return 'Nothing to do — this folder is already PARA-organised or empty.';
+        const bits = [];
+        if (counts.projects) bits.push(`${counts.projects} to Projects`);
+        if (counts.areas) bits.push(`${counts.areas} to Areas`);
+        if (counts.resources) bits.push(`${counts.resources} to Resources`);
+        if (counts.archives) bits.push(`${counts.archives} to Archives`);
+        return `PARA plan: ${bits.join(', ')}. Every move is reversible after apply.`;
+    }
+}
+
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// ─── Teaching READMEs (the democratization layer) ─────────────────
+// Plain-English so a first-timer who has never heard of PARA gets it.
+const PARA_READMES = {
+    projects: `# Projects
+
+**Active efforts with a goal and an end.** One folder per project.
+
+A project is anything you are *currently* working toward finishing:
+a trip you're planning, a deliverable due next month, a room you're
+renovating. When a project is done, move its folder to \`Archives\`.
+
+FileMayor places recently-modified files and anything that looks like
+active work here. You stay in control — review before applying.
+
+_PARA is a method created by Tiago Forte (Building a Second Brain).
+FileMayor automates it; it is not affiliated with or endorsed by him._
+`,
+    areas: `# Areas
+
+**Ongoing responsibilities you maintain — with no end date.**
+
+Areas are the standing parts of your life and work: Finances, Health,
+Home, a job role, a car you own. There's no "done" — you just keep them
+in good order. One folder per area (e.g. \`Finances\`, \`Health\`).
+
+FileMayor routes files whose names or folders match common areas
+(taxes, invoices, insurance, health…) here.
+
+_PARA method by Tiago Forte. FileMayor automates it; not affiliated._
+`,
+    resources: `# Resources
+
+**Topics and reference material you may want later.**
+
+Things that aren't tied to a current project or a responsibility, but
+are worth keeping: reference docs, templates, books, fonts, design
+assets, inspiration. One folder per topic.
+
+FileMayor places reference-type files (books, fonts, design) and
+anything in \`reference/\`, \`templates/\`, etc. here.
+
+_PARA method by Tiago Forte. FileMayor automates it; not affiliated._
+`,
+    archives: `# Archives
+
+**Inactive items from the other three categories.**
+
+Nothing is deleted — Archives is cold storage. When a project finishes
+or a resource stops being useful, it moves here, out of the way but
+recoverable.
+
+FileMayor automatically moves files you haven't touched in a long time
+(12+ months by default) here. This is the chore PARA users hate doing
+by hand — so FileMayor does it for you.
+
+_PARA method by Tiago Forte. FileMayor automates it; not affiliated._
+`,
+};
+
+module.exports = PARAEngine;
+module.exports.DEFAULT_PARA = DEFAULT_PARA;
+module.exports.PARA_READMES = PARA_READMES;

package/core/index.js

@@ -27,6 +27,7 @@ const CureEngine = require('./engine/cure-engine');
 const ApplyEngine = require('./engine/apply-engine');
 const PreviewEngine = require('./engine/preview-engine');
 const DedupeEngine = require('./engine/dedupe-engine');
+const PARAEngine = require('./engine/para-engine');
 const MetadataStore = require('./metadata-store');
 const strategist = require('./ai/strategist');
 const sentry = require('./ai/sentry');
@@ -119,6 +120,7 @@ module.exports = {
     ApplyEngine,
     PreviewEngine,
     DedupeEngine,
+    PARAEngine,
     MetadataStore,
 
     // Hardened Runtime

package/index.js

@@ -51,13 +51,14 @@ const { formatBytes } = require('./core/scanner');
 const { getCategories } = require('./core/categories');
 const { checkPermissions } = require('./core/security');
 const { activateLicense, deactivateLicense, getLicenseInfo, checkProFeature, checkBulkLimit } = require('./core/license');
-const { ExplainEngine, CureEngine, ApplyEngine, DedupeEngine } = require('./core/index');
+const { ExplainEngine, CureEngine, ApplyEngine, DedupeEngine, PARAEngine } = require('./core/index');
 const { ping: telemetryPing } = require('./core/telemetry');
 
 const { c, banner, Spinner, success, error, warn, info } = reporter;
 
 // ─── Version ──────────────────────────────────────────────────────
-const VERSION = '4.0.5';
+// Derived from package.json so it can never drift out of sync.
+const VERSION = require('./package.json').version;
 
 // ─── Path Helpers ─────────────────────────────────────────────────
 
@@ -117,6 +118,10 @@ function parseArgs(argv) {
             args.flags.depth = parseInt(raw[++i], 10);
         } else if (arg === '--naming' && raw[i + 1]) {
             args.flags.naming = raw[++i];
+        } else if (arg === '--archive-after' && raw[i + 1]) {
+            args.flags.archiveAfter = parseInt(raw[++i], 10);
+        } else if (arg === '--para') {
+            args.flags.para = true;
         } else if (arg === '--output' && raw[i + 1]) {
             args.flags.outputDir = raw[++i];
         } else if (arg === '--config' && raw[i + 1]) {
@@ -182,9 +187,10 @@ ${banner()}
     ${c('yellow', 'scan')}      ${c('dim', '<path>')}    Scan directory and report contents
     ${c('yellow', 'analyze')}   ${c('dim', '<path>')}    Deep analysis (duplicates, bloat, savings)
     ${c('yellow', 'organize')}  ${c('dim', '<path>')}    Organize files into categories
+    ${c('yellow', 'para')}      ${c('dim', '<path>')}    Sort by actionability — PARA method (then apply)
     ${c('yellow', 'clean')}     ${c('dim', '<path>')}    Find and remove junk files
     ${c('yellow', 'watch')}     ${c('dim', '<path>')}    Watch directory for changes
-    ${c('yellow', 'init')}                Create .filemayor.yml config
+    ${c('yellow', 'init')}     ${c('dim', '[--para]')}   Create .filemayor.yml (--para scaffolds PARA folders)
     ${c('yellow', 'undo')}      ${c('dim', '<path>')}    Undo last organization
     ${c('yellow', 'info')}                System info and version
     ${c('yellow', 'license')}  ${c('dim', '<action>')}  Manage license (activate|status|deactivate)
@@ -201,6 +207,8 @@ ${banner()}
     ${c('dim', '--config <path>')}     Custom config file
     ${c('dim', '--depth <n>')}         Max recursion depth
     ${c('dim', '--naming <type>')}     Naming: original|category_prefix|date_prefix|clean
+    ${c('dim', '--archive-after <n>')} PARA: months of inactivity before a file → Archives
+    ${c('dim', '--para')}              init: scaffold PARA folders + preset config
     ${c('dim', '--duplicates <s>')}    Duplicates: rename|skip|overwrite
     ${c('dim', '--extensions <e>')}    Filter by extensions (comma-separated)
     ${c('dim', '--output <path>')}     Output directory for organized files
@@ -214,6 +222,8 @@ ${banner()}
     ${c('dim', '$')} filemayor scan ~/Downloads
     ${c('dim', '$')} filemayor organize ~/Downloads --dry-run
     ${c('dim', '$')} filemayor organize ~/Downloads --naming category_prefix
+    ${c('dim', '$')} filemayor init --para ~/Documents
+    ${c('dim', '$')} filemayor para ~/Documents --archive-after 18
     ${c('dim', '$')} filemayor clean /var/tmp --yes
     ${c('dim', '$')} filemayor scan . --json | jq '.files | length'
     ${c('dim', '$')} filemayor watch ~/Downloads
@@ -454,6 +464,23 @@ async function cmdWatch(target, flags, config) {
 
 async function cmdInit(flags) {
     try {
+        if (flags.para) {
+            // PARA preset: write a tuned config AND scaffold the four folders
+            // with teaching READMEs so a first-timer understands the method.
+            const configPath = createConfigFile(process.cwd(), '.filemayor.yml', 'para');
+            console.log(success(`Created ${c('cyan', configPath)}`));
+
+            const engine = new PARAEngine();
+            const { created, folders } = engine.scaffold(process.cwd());
+            console.log(success(`Scaffolded PARA folders: ${c('cyan', Object.values(folders).join(', '))}`));
+            if (created.length) {
+                console.log(c('dim', `  ${created.length} item(s) created (folders + READMEs)`));
+            }
+            console.log('');
+            console.log(c('dim', '  Next:  ') + c('cyan', 'filemayor para .') + c('dim', '   then  ') + c('cyan', 'filemayor apply'));
+            return;
+        }
+
         const configPath = createConfigFile(process.cwd());
         console.log(success(`Created ${c('cyan', configPath)}`));
         console.log(c('dim', '  Edit this file to customize FileMayor settings'));
@@ -463,6 +490,55 @@ async function cmdInit(flags) {
     }
 }
 
+// ─── PARA: sort by actionability (Projects/Areas/Resources/Archives) ──
+async function cmdPara(target, flags, config) {
+    const targetPath = path.resolve(target || '.');
+
+    // Per-run override for the archive threshold.
+    const paraConfig = { ...(config.para || {}) };
+    if (Number.isFinite(flags.archiveAfter)) {
+        paraConfig.archiveAfterMonths = flags.archiveAfter;
+    }
+
+    const spinner = new Spinner(`Sorting ${c('cyan', targetPath)} by actionability (PARA)...`);
+    if (!flags.quiet) spinner.start();
+
+    try {
+        const engine = new PARAEngine(paraConfig);
+        const result = engine.plan(targetPath);
+        spinner.stop();
+
+        if (flags.format === 'json') {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+
+        // Cache the plan so `filemayor apply` can execute it (same path as cure).
+        const cachePath = path.join(os.tmpdir(), 'filemayor-plan.json');
+        fs.writeFileSync(cachePath, JSON.stringify(result), 'utf8');
+
+        console.log(reporter.formatCureReport(result));
+
+        // PARA-specific breakdown — the bucket is the whole point.
+        const b = result.summary.buckets;
+        console.log(c('bold', '  Into PARA buckets:'));
+        console.log(`    ${c('cyan', 'Projects')}  ${b.projects}   ${c('cyan', 'Areas')} ${b.areas}   ${c('cyan', 'Resources')} ${b.resources}   ${c('cyan', 'Archives')} ${b.archives}`);
+        for (const wn of (result.warnings || [])) {
+            console.log(c('dim', `    ⚠ ${wn}`));
+        }
+
+        if (result.plan.length === 0) {
+            console.log(info('Nothing to reorganise — run with a messier folder, or it is already PARA-sorted.'));
+        } else {
+            console.log('');
+            console.log(c('dim', '  Review the plan above, then run ') + c('cyan', 'filemayor apply') + c('dim', ' to execute (reversible with ') + c('cyan', 'filemayor undo') + c('dim', ').'));
+        }
+    } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+    }
+}
+
 async function cmdUndo(target, flags) {
     const { JOURNAL_PATH, rollback: fsRollback } = require('./core/fs-abstraction');
 
@@ -837,6 +913,11 @@ async function main() {
             await cmdOrganize(args.target, args.flags, config);
             break;
 
+        case 'para':
+        case 'pm':
+            await cmdPara(args.target, args.flags, config);
+            break;
+
         case 'clean':
         case 'cl':
         case 'c':

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "filemayor",
-    "version": "4.0.7",
+    "version": "4.0.8",
     "description": "FileMayor — Your intelligent filesystem clerk. CLI + Desktop + PWA.",
     "main": "index.js",
     "bin": {