@claude-flow/cli 3.56.3 → 3.56.5

package/dist/src/commands/plugins.js

@@ -8,7 +8,7 @@
 import { output } from '../output.js';
 import { createPluginDiscoveryService, searchPlugins, getPluginSearchSuggestions, getFeaturedPlugins, getOfficialPlugins, } from '../plugins/store/index.js';
 import { getPluginManager } from '../plugins/manager.js';
-import { DEFAULT_PLUGIN_PERMISSIONS } from '../plugins/trust-policy.js';
+import { DEFAULT_PLUGIN_PERMISSIONS, isStrictPluginMode } from '../plugins/trust-policy.js';
 import { getBulkRatings } from '../services/registry-api.js';
 // List subcommand - Now uses IPFS-based registry
 const listCommand = {
@@ -92,6 +92,9 @@ const listCommand = {
                 spinner.stop(output.warning(`Signed plugin registry unavailable or unverified; showing the built-in list ` +
                     `(${result.registry.totalPlugins} plugins)`));
             }
+            else if (result.verified !== true) {
+                spinner.stop(output.warning(`Registry discovered but not verified: ${result.registry.totalPlugins} plugins available`));
+            }
             else {
                 spinner.succeed(`Registry discovered: ${result.registry.totalPlugins} plugins available`);
             }
@@ -108,6 +111,9 @@ const listCommand = {
             if (official) {
                 plugins = getOfficialPlugins(result.registry);
                 title = 'Official Plugins';
+                if (result.verified !== true) {
+                    output.writeln(output.warning('No plugin is shown as official: only a verified registry can say which are.'));
+                }
             }
             else if (featured) {
                 plugins = getFeaturedPlugins(result.registry);
@@ -174,9 +180,13 @@ const listCommand = {
             }
             output.writeln(output.dim(`Source: ${result.source}${result.fromCache ? ' (cached)' : ''}`));
             if (result.demo) {
-                output.writeln(output.warning('Not from the signed registry: download counts, ratings and trust labels are the ' +
+                output.writeln(output.warning('Not from the signed registry: download counts and ratings are the ' +
                     "CLI's built-in defaults, not verified registry data."));
             }
+            if (result.verified !== true) {
+                output.writeln(output.warning(`Registry not verified (${result.unverifiedReason ?? 'unknown reason'}): every entry is ` +
+                    'shown as Unverified and installs get no registry trust.'));
+            }
             if (result.cid) {
                 output.writeln(output.dim(`Registry CID: ${result.cid.slice(0, 30)}...`));
             }
@@ -208,6 +218,15 @@ const installCommand = {
             default: true,
         },
         { name: 'trust', type: 'boolean', description: 'Register hooks and commands even if the plugin is untrusted or declares elevated permissions', default: false },
+        {
+            name: 'allow-unverified',
+            type: 'boolean',
+            description: 'With CLAUDE_FLOW_STRICT_PLUGINS=true, install from npm even though the plugin registry is not verified. ' +
+                'The plugin still gets no registry trust. Strict mode gates on the registry, not the package: while the ' +
+                'registry is unverified every npm install is refused, listed or not; once it verifies, a package it does ' +
+                'not list installs without this flag, but also without registry trust.',
+            default: false,
+        },
         { name: 'registry', short: 'r', type: 'string', description: 'Registry to use' },
     ],
     examples: [
@@ -221,6 +240,7 @@ const installCommand = {
         const registryName = ctx.flags.registry;
         const verify = ctx.flags.verify !== false;
         const trust = ctx.flags.trust === true;
+        const allowUnverified = ctx.flags.allowUnverified === true || ctx.flags['allow-unverified'] === true;
         if (!name) {
             output.printError('Plugin name is required');
             return { success: false, exitCode: 1 };
@@ -248,6 +268,7 @@ const installCommand = {
             }
             let result;
             let plugin;
+            const registryWarnings = [];
             if (isLocalPath) {
                 // Install from local path
                 spinner.setText(`Installing from ${name}...`);
@@ -261,17 +282,37 @@ const installCommand = {
                 if (registryResult.success && registryResult.registry) {
                     plugin = registryResult.registry.plugins.find(p => p.name === name || p.id === name);
                 }
+                // Only a verified registry may vouch for a plugin (trust level, permissions, checksum).
+                // An unverified or built-in list is just a claim, so its entries install like any npm
+                // package: no install scripts and no permission vouching without --trust.
+                const registryVerified = registryResult.success && registryResult.verified === true;
+                if (!registryVerified) {
+                    const reason = registryResult.unverifiedReason ?? registryResult.error ?? 'registry not verified';
+                    if (isStrictPluginMode() && !allowUnverified) {
+                        spinner.fail(`Refusing to install ${name}: plugin registry is not verified (${reason})`);
+                        output.writeln();
+                        output.writeln(output.dim('CLAUDE_FLOW_STRICT_PLUGINS=true requires a verified registry. Pass --allow-unverified to install it ' +
+                            'from npm anyway, without registry trust.'));
+                        return { success: false, exitCode: 1 };
+                    }
+                    if (plugin) {
+                        registryWarnings.push(`${name} is listed only in an unverified registry (${reason}); it was installed without registry trust.`);
+                    }
+                }
                 if (plugin) {
                     spinner.setText(`Found ${plugin.displayName} v${plugin.version}`);
                 }
-                // Install from npm (since IPFS is demo mode)
                 spinner.setText(`Installing ${name} from npm...`);
                 result = await manager.installFromNpm(name, version !== 'latest' ? version : undefined, {
                     verify,
                     trust,
-                    expectedChecksum: plugin?.checksum,
-                    registryTrustLevel: plugin?.trustLevel,
-                    registryPermissions: plugin?.permissions,
+                    ...(registryVerified && plugin
+                        ? {
+                            expectedChecksum: plugin.checksum,
+                            registryTrustLevel: plugin.trustLevel,
+                            registryPermissions: plugin.permissions,
+                        }
+                        : {}),
                 });
             }
             if (!result.success) {
@@ -284,7 +325,7 @@ const installCommand = {
             if (result.decision?.verificationSkipped) {
                 output.printWarning('Verification skipped (--no-verify): hooks and commands were registered without a trust or checksum check.');
             }
-            for (const warning of result.warnings ?? []) {
+            for (const warning of [...registryWarnings, ...(result.warnings ?? [])]) {
                 output.printWarning(warning);
             }
             const boxContent = [
@@ -460,6 +501,8 @@ const infoCommand = {
             const result = await discovery.discoverRegistry(registryName);
             if (!result.success || !result.registry) {
                 spinner.fail('Failed to discover registry');
+                if (result.error)
+                    output.printError(result.error);
                 return { success: false, exitCode: 1 };
             }
             const plugin = result.registry.plugins.find(p => p.name === name || p.id === name);
@@ -491,6 +534,7 @@ const infoCommand = {
                     { field: 'Author', value: plugin.author.displayName || plugin.author.id },
                     { field: 'Trust Level', value: plugin.trustLevel },
                     { field: 'Verified', value: plugin.verified ? '✓ Yes' : '✗ No' },
+                    { field: 'Registry', value: result.verified === true ? 'verified' : `unverified (${result.unverifiedReason ?? 'unknown reason'})` },
                 ],
             });
             output.writeln();
@@ -640,6 +684,21 @@ const upgradeCommand = {
     options: [
         { name: 'name', short: 'n', type: 'string', description: 'Plugin name', required: true },
         { name: 'version', short: 'v', type: 'string', description: 'Target version (default: latest)' },
+        {
+            name: 'verify',
+            type: 'boolean',
+            description: 'Re-apply the install trust policy to the new version (default: true). Its hooks and commands are withheld ' +
+                `if it declares trustLevel "untrusted"/"unverified" or permissions beyond the default set (${DEFAULT_PLUGIN_PERMISSIONS.join(', ')}) ` +
+                'unless --trust is given. --no-verify skips this.',
+            default: true,
+        },
+        {
+            name: 'trust',
+            type: 'boolean',
+            description: "Run the new version's install scripts and register its hooks and commands even if it is untrusted or " +
+                'declares elevated permissions. Not carried over from the original install.',
+            default: false,
+        },
     ],
     examples: [
         { command: 'claude-flow plugins upgrade -n @claude-flow/neural', description: 'Upgrade to latest' },
@@ -648,6 +707,8 @@ const upgradeCommand = {
     action: async (ctx) => {
         const name = ctx.flags.name;
         const version = ctx.flags.version;
+        const verify = ctx.flags.verify !== false;
+        const trust = ctx.flags.trust === true;
         if (!name) {
             output.printError('Plugin name is required');
             return { success: false, exitCode: 1 };
@@ -666,13 +727,23 @@ const upgradeCommand = {
             }
             const oldVersion = existing.version;
             spinner.setText(`Upgrading ${name} from v${oldVersion}...`);
-            const result = await manager.upgrade(name, version);
+            const result = await manager.upgrade(name, version, { verify, trust });
             if (!result.success) {
                 spinner.fail(`Upgrade failed: ${result.error}`);
                 return { success: false, exitCode: 1 };
             }
             const plugin = result.plugin;
             spinner.succeed(`Upgraded ${name}: v${oldVersion} -> v${plugin.version}`);
+            if (result.decision?.verificationSkipped) {
+                output.printWarning('Verification skipped (--no-verify): hooks and commands were registered without a trust check.');
+            }
+            for (const warning of result.warnings ?? []) {
+                output.printWarning(warning);
+            }
+            if (plugin.withheld) {
+                output.printWarning(`Withheld ${plugin.withheld.hooks.length} hook(s) and ${plugin.withheld.commands.length} command(s) ` +
+                    `from ${plugin.name} because it ${plugin.withheld.reasons.join('; ')}. Upgrade with --trust to register them.`);
+            }
             return { success: true, data: plugin };
         }
         catch (error) {
@@ -716,6 +787,8 @@ const searchCommand = {
             const result = await discovery.discoverRegistry(registryName);
             if (!result.success || !result.registry) {
                 spinner.fail('Failed to discover registry');
+                if (result.error)
+                    output.printError(result.error);
                 return { success: false, exitCode: 1 };
             }
             const searchOptions = {

package/dist/src/commands/security-code-patterns.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Line patterns for `security scan` phase 3, and what each line is tested on.
+ *
+ * The patterns are a heuristic. Each is narrowed only where a false positive was seen on a real tree, and only by a
+ * shape that cannot carry the risk the rule looks for:
+ *  - every rule is tested after comment text is blanked, so a comment naming `child_process.execFile` or `eval(` is
+ *    not a finding;
+ *  - eval needs a word start: "retrieval (" in prose is not a call; `eval(` and `window.eval(` still are;
+ *  - command injection keeps the old rule's reach (any `exec` after `child_process` on the line), and no longer skips
+ *    execSync as `exec[^S]` did;
+ *  - a pg placeholder such as `$${paramCount + 1}` is a parameter number, not a value in the SQL text. It is exempt only
+ *    when its expression is a number, a loop letter, `params.length`-style, or a name containing `param` or `placeholder`, it
+ *    stands where SQL takes a value, and it is not inside a quoted SQL string.
+ */
+export type CodePattern = {
+    /** Tested on one comment-stripped line. */
+    match: (line: string) => boolean;
+    type: string;
+    severity: 'high' | 'medium';
+    desc: string;
+};
+/**
+ * `$${paramCount}` / `LIMIT $${params.length + 1}`: the pg parameter number where SQL takes a value, not interpolated
+ * SQL text. `'$${n}'`, `"$${n}"`, `$${userInput}` and `x $${discount}` keep their interpolation. One left-to-right
+ * pass: quotes are counted since the last backtick, so a placeholder inside a quoted SQL string keeps its finding.
+ */
+export declare const withoutPlaceholders: (line: string) => string;
+export declare const CODE_PATTERNS: readonly CodePattern[];
+/**
+ * The file's lines with comment text blanked (line count kept, so locations stay right). Strings are respected, so
+ * `'http://x'` is not a comment; a template literal may span lines. Regex literals and JSX text are not parsed, so a
+ * `//`, `/*` or backtick inside one can be misread. The damage is bounded to one line: a block comment carries to the
+ * next line only from a `/*` that starts its line, and only through lines that look like comment lines (they start
+ * with `*` or contain the closing `*` + `/`). Any other line ends the carried comment and is scanned as code. One pass,
+ * linear in the file size.
+ */
+export declare function codeLinesOf(content: string): string[];
+/** True for an istanbul or Playwright asset, given its parent folder's name and what the parent folder holds. */
+export declare function isGeneratedReportAsset(parentName: string, entryName: string, parentHas: (name: string) => boolean): boolean;
+//# sourceMappingURL=security-code-patterns.d.ts.map

package/dist/src/commands/security-code-patterns.js

@@ -0,0 +1,192 @@
+/**
+ * Line patterns for `security scan` phase 3, and what each line is tested on.
+ *
+ * The patterns are a heuristic. Each is narrowed only where a false positive was seen on a real tree, and only by a
+ * shape that cannot carry the risk the rule looks for:
+ *  - every rule is tested after comment text is blanked, so a comment naming `child_process.execFile` or `eval(` is
+ *    not a finding;
+ *  - eval needs a word start: "retrieval (" in prose is not a call; `eval(` and `window.eval(` still are;
+ *  - command injection keeps the old rule's reach (any `exec` after `child_process` on the line), and no longer skips
+ *    execSync as `exec[^S]` did;
+ *  - a pg placeholder such as `$${paramCount + 1}` is a parameter number, not a value in the SQL text. It is exempt only
+ *    when its expression is a number, a loop letter, `params.length`-style, or a name containing `param` or `placeholder`, it
+ *    stands where SQL takes a value, and it is not inside a quoted SQL string.
+ */
+/** No `g` flag, so `test` keeps no lastIndex between lines. */
+const re = (pattern) => (line) => pattern.test(line);
+// A `.length` counts only on a param-, value- or arg-named array: `req.body.length` is whatever the client sent.
+const COUNTER = /^\s*(?:\d+|[ijkn]|(?:[A-Za-z_$][\w$]*(?:Params?|Placeholders?|Values?|Args?)|params?|placeholders?|values?|args?)\.length|[A-Za-z_$]*(?:[Pp]aram|[Pp]laceholder)[\w$]*)\s*(?:[+-]\s*\d+\s*)?$/;
+// Where a pg parameter stands in SQL: after a comparison, a list or call opener, or a clause keyword.
+const PARAM_BEFORE = /(?:[=<>(,]|\b(?:LIMIT|OFFSET|IN|VALUES|BETWEEN|AND|OR|LIKE|ILIKE|SET|BY|THEN|ELSE|WHEN|IS))\s*$/i;
+const PARAM_AFTER = /^(?:\s|[,);]|::|$|`)/;
+/**
+ * `$${paramCount}` / `LIMIT $${params.length + 1}`: the pg parameter number where SQL takes a value, not interpolated
+ * SQL text. `'$${n}'`, `"$${n}"`, `$${userInput}` and `x $${discount}` keep their interpolation. One left-to-right
+ * pass: quotes are counted since the last backtick, so a placeholder inside a quoted SQL string keeps its finding.
+ */
+export const withoutPlaceholders = (line) => {
+    const token = /\\[\s\S]|\$\$\{([^}]{0,80})\}|[`'"]/g;
+    let single = 0;
+    let double = 0;
+    let out = '';
+    let kept = 0;
+    for (let m = token.exec(line); m !== null; m = token.exec(line)) {
+        if (m[0][0] === '\\')
+            continue;
+        if (m[0] === '`') {
+            single = 0;
+            double = 0;
+            continue;
+        }
+        if (m[0] === "'") {
+            single++;
+            continue;
+        }
+        if (m[0] === '"') {
+            double++;
+            continue;
+        }
+        const end = m.index + m[0].length;
+        const isParam = single % 2 === 0 && double % 2 === 0 && COUNTER.test(m[1])
+            && PARAM_BEFORE.test(line.slice(Math.max(0, m.index - 16), m.index)) && PARAM_AFTER.test(line.slice(end, end + 2));
+        if (isParam) {
+            out += line.slice(kept, m.index);
+            kept = end;
+        }
+    }
+    return out + line.slice(kept);
+};
+/** The old `/\$\{.*\}.*sql|sql.*\$\{/i`, in linear time: a long minified line made the regex quadratic. */
+const sqlInterpolation = (line) => {
+    const lower = line.toLowerCase();
+    const open = line.indexOf('${');
+    const close = open < 0 ? -1 : line.indexOf('}', open + 2);
+    if (close >= 0 && lower.indexOf('sql', close + 1) >= 0)
+        return true;
+    const sql = lower.indexOf('sql');
+    return sql >= 0 && line.indexOf('${', sql + 3) >= 0;
+};
+export const CODE_PATTERNS = [
+    { match: re(/(?<![\w$])eval\s*\(/), type: 'Eval Usage', severity: 'medium', desc: 'eval() can execute arbitrary code' },
+    { match: re(/innerHTML\s*=/), type: 'innerHTML', severity: 'medium', desc: 'XSS risk with innerHTML' },
+    { match: re(/dangerouslySetInnerHTML/), type: 'React XSS', severity: 'medium', desc: 'React XSS risk' },
+    { match: re(/child_process.*exec/), type: 'Command Injection', severity: 'high', desc: 'Possible command injection' },
+    { match: line => sqlInterpolation(line) && sqlInterpolation(withoutPlaceholders(line)), type: 'SQL Injection', severity: 'high', desc: 'Possible SQL injection' },
+];
+/**
+ * The file's lines with comment text blanked (line count kept, so locations stay right). Strings are respected, so
+ * `'http://x'` is not a comment; a template literal may span lines. Regex literals and JSX text are not parsed, so a
+ * `//`, `/*` or backtick inside one can be misread. The damage is bounded to one line: a block comment carries to the
+ * next line only from a `/*` that starts its line, and only through lines that look like comment lines (they start
+ * with `*` or contain the closing `*` + `/`). Any other line ends the carried comment and is scanned as code. One pass,
+ * linear in the file size.
+ */
+export function codeLinesOf(content) {
+    const out = [];
+    let inBlock = false;
+    let inTemplate = false;
+    for (const line of content.split('\n')) {
+        if (inBlock && !/^\s*\*|\*\//.test(line))
+            inBlock = false;
+        const parts = [];
+        let tail = '';
+        let hasCode = false;
+        let quote = inTemplate ? '`' : null;
+        let carries = inBlock;
+        // Parts plus a 12-character tail, not one growing string: slicing a concatenated string flattens it each time.
+        const emit = (text) => {
+            parts.push(text);
+            tail = (tail + text).slice(-12);
+            if (/\S/.test(text))
+                hasCode = true;
+        };
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            const next = line[i + 1];
+            if (inBlock) {
+                if (ch === '*' && next === '/') {
+                    inBlock = false;
+                    i++;
+                    emit(' ');
+                }
+                continue;
+            }
+            if (ch === '\\') {
+                emit(ch + (next ?? ''));
+                i++;
+                continue;
+            }
+            if (quote !== null) {
+                if (ch === quote)
+                    quote = null;
+                emit(ch);
+                continue;
+            }
+            // `://` is a URL scheme, not a comment.
+            if (ch === '/' && next === '/' && line[i - 1] !== ':')
+                break;
+            if (ch === '/' && next === '*') {
+                inBlock = true;
+                carries = !hasCode;
+                i++;
+                emit(' ');
+                continue;
+            }
+            if (ch === '/' && REGEX_MAY_START.test(tail)) {
+                const end = regexEnd(line, i);
+                if (end > i) {
+                    emit(line.slice(i, end + 1));
+                    i = end;
+                    continue;
+                }
+            }
+            if (ch === '"' || ch === "'" || ch === '`')
+                quote = ch;
+            emit(ch);
+        }
+        if (inBlock && !carries)
+            inBlock = false;
+        inTemplate = quote === '`';
+        out.push(parts.join(''));
+    }
+    return out;
+}
+/** Code so far ends where an expression starts, so a `/` there opens a regex literal, not a division. */
+const REGEX_MAY_START = /(?:^|[(,=:[!&|?{};+\-*%<>~^]|\b(?:return|typeof|case|do|else|in|of|void|yield|await))\s*$/;
+/**
+ * The index of the `/` closing a regex literal that opens at `start`, or -1 when the line has none (then it was a
+ * division). Its text is kept as code, so misreading a regex can only keep comment text, never blank code.
+ */
+function regexEnd(line, start) {
+    let inClass = false;
+    // Bounded, so a line of `(/` cannot make the stripper quadratic; a longer regex is read as code, which is safe.
+    for (let i = start + 1; i < Math.min(line.length, start + 200); i++) {
+        const ch = line[i];
+        if (ch === '\\') {
+            i++;
+            continue;
+        }
+        if (ch === '[')
+            inClass = true;
+        else if (ch === ']')
+            inClass = false;
+        else if (ch === '/' && !inClass)
+            return i;
+    }
+    return -1;
+}
+/**
+ * Generated report assets, named by what the report writes, inside a folder its marker file identifies. Only those
+ * entries are skipped: other files in a folder that merely shares the name are still scanned.
+ */
+const REPORT_ASSETS = new Map([
+    ['coverage', { markers: ['coverage-final.json', 'lcov.info', 'clover.xml'], assets: new Set(['prettify.js', 'sorter.js', 'block-navigation.js', 'lcov-report']) }],
+    ['playwright-report', { markers: ['index.html'], assets: new Set(['trace', 'data']) }],
+]);
+/** True for an istanbul or Playwright asset, given its parent folder's name and what the parent folder holds. */
+export function isGeneratedReportAsset(parentName, entryName, parentHas) {
+    // A Map, so a folder named `constructor` or `__proto__` is not looked up on Object.prototype.
+    const report = REPORT_ASSETS.get(parentName);
+    return report !== undefined && report.assets.has(entryName) && report.markers.some(parentHas);
+}
+//# sourceMappingURL=security-code-patterns.js.map

package/dist/src/commands/security.js

@@ -9,6 +9,7 @@ import { execSync } from 'node:child_process';
 import { existsSync, statSync } from 'node:fs';
 import { resolve as resolvePath } from 'node:path';
 import { createBuiltinAIDefence } from '../security/builtin-aidefence.js';
+import { CODE_PATTERNS, codeLinesOf, isGeneratedReportAsset } from './security-code-patterns.js';
 // Accepted values for `security scan`'s enum flags — the single source of truth
 // for both validation and the traversal-depth maps below.
 const SCAN_DEPTHS = ['quick', 'standard', 'deep'];
@@ -269,13 +270,7 @@ const scanCommand = {
             // Phase 3: Check for common security issues in code
             if ((scanType === 'all' || scanType === 'code') && depth !== 'quick') {
                 spinner.setText('Analyzing code patterns...');
-                const codePatterns = [
-                    { pattern: /eval\s*\(/g, type: 'Eval Usage', severity: 'medium', desc: 'eval() can execute arbitrary code' },
-                    { pattern: /innerHTML\s*=/g, type: 'innerHTML', severity: 'medium', desc: 'XSS risk with innerHTML' },
-                    { pattern: /dangerouslySetInnerHTML/g, type: 'React XSS', severity: 'medium', desc: 'React XSS risk' },
-                    { pattern: /child_process.*exec[^S]/g, type: 'Command Injection', severity: 'high', desc: 'Possible command injection' },
-                    { pattern: /\$\{.*\}.*sql|sql.*\$\{/gi, type: 'SQL Injection', severity: 'high', desc: 'Possible SQL injection' },
-                ];
+                // The patterns, and the comment stripping they are tested after, live in security-code-patterns.ts.
                 const scanCodeDir = (dir, depthLimit) => {
                     // Positive-test rather than `<= 0`: undefined and NaN both fail this,
                     // so a bad budget stops the recursion instead of disabling the limiter.
@@ -287,16 +282,19 @@ const scanCommand = {
                             if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist')
                                 continue;
                             const fullPath = path.join(dir, entry.name);
+                            // Coverage and Playwright report assets bundle third-party code (prettify, CodeMirror, React), not the project's.
+                            if (isGeneratedReportAsset(path.basename(dir), entry.name, name => fs.existsSync(path.join(dir, name))))
+                                continue;
                             if (entry.isDirectory()) {
                                 scanCodeDir(fullPath, depthLimit - 1);
                             }
                             else if (entry.isFile() && /\.(ts|js|tsx|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
                                 try {
                                     const content = fs.readFileSync(fullPath, 'utf-8');
-                                    const lines = content.split('\n');
+                                    const lines = codeLinesOf(content);
                                     for (let i = 0; i < lines.length; i++) {
-                                        for (const { pattern, type, severity, desc } of codePatterns) {
-                                            if (pattern.test(lines[i])) {
+                                        for (const { match, type, severity, desc } of CODE_PATTERNS) {
+                                            if (match(lines[i])) {
                                                 if (severity === 'high')
                                                     highCount++;
                                                 else
@@ -307,7 +305,6 @@ const scanCommand = {
                                                     location: `${path.relative(target, fullPath)}:${i + 1}`,
                                                     description: desc,
                                                 });
-                                                pattern.lastIndex = 0;
                                             }
                                         }
                                     }

package/dist/src/commands/status.js

@@ -415,7 +415,7 @@ const agentsCommand = {
     description: 'Show detailed agent status',
     action: async (ctx) => {
         try {
-            const result = await callMCPTool('agent_list', { includeMetrics: true, status: 'all' });
+            const result = await callMCPTool('agent_list', {});
             if (ctx.flags.format === 'json') {
                 output.printJson(result);
                 return { success: true, data: result };
@@ -424,7 +424,7 @@ const agentsCommand = {
             output.writeln(output.bold('Agent Status'));
             output.writeln();
             if (result.agents.length === 0) {
-                output.printInfo('No agents running');
+                output.printInfo('No agents registered');
                 return { success: true, data: result };
             }
             output.printTable({
@@ -432,17 +432,15 @@ const agentsCommand = {
                     { key: 'id', header: 'ID', width: 20 },
                     { key: 'type', header: 'Type', width: 12 },
                     { key: 'status', header: 'Status', width: 10 },
-                    { key: 'task', header: 'Current Task', width: 25 },
-                    { key: 'uptime', header: 'Uptime', width: 12 },
-                    { key: 'success', header: 'Success', width: 8 }
+                    { key: 'tasks', header: 'Tasks', width: 8 },
+                    { key: 'health', header: 'Health', width: 8 }
                 ],
                 data: result.agents.map(a => ({
-                    id: a.id,
-                    type: a.type,
+                    id: a.agentId,
+                    type: a.agentType,
                     status: formatHealth(a.status),
-                    task: a.task || '-',
-                    uptime: formatUptime(a.uptime),
-                    success: `${(a.metrics.successRate * 100).toFixed(0)}%`
+                    tasks: a.taskCount,
+                    health: a.health
                 }))
             });
             return { success: true, data: result };

package/dist/src/init/executor.d.ts

@@ -35,7 +35,7 @@ export interface UpgradeResult {
  * Preserves user customizations while adding new features like Agent Teams
  * Uses platform-specific commands for Mac, Linux, and Windows
  */
-export declare function mergeSettingsForUpgrade(existing: Record<string, unknown>): {
+export declare function mergeSettingsForUpgrade(existing: Record<string, unknown>, targetDir?: string): {
     merged: Record<string, unknown>;
     warnings: string[];
 };