@wrongstack/core 0.5.3 → 0.5.6

package/dist/index.js

@@ -2,7 +2,9 @@ import * as crypto2 from 'crypto';
 import { randomBytes, createCipheriv, createDecipheriv, randomUUID, createHash } from 'crypto';
 import * as fs from 'fs';
 import * as fsp2 from 'fs/promises';
+import { readFile, readdir, writeFile, stat, mkdir } from 'fs/promises';
 import * as path6 from 'path';
+import { join, extname, relative } from 'path';
 import * as os4 from 'os';
 import { EventEmitter } from 'events';
 import { createGunzip } from 'zlib';
@@ -10,6 +12,13 @@ import { Readable } from 'stream';
 import { pipeline } from 'stream/promises';
 import { spawn } from 'child_process';
 
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/types/errors.ts
 var WrongStackError = class extends Error {
   code;
@@ -506,6 +515,103 @@ var EventBus = class {
     return this.wildcards.length;
   }
 };
+var ScopedEventBus = class extends EventBus {
+  // Track registrations by a unique counter key so that EventBus.once()'s
+  // internal listener-removal doesn't affect our tracking (once removes the
+  // fn from EventBus but we still need to call our unsub during teardown).
+  registrations = /* @__PURE__ */ new Map();
+  nextKey = 0;
+  /**
+   * Identical to `EventBus.on` but the listener is tracked so that
+   * `teardown()` will remove it automatically.
+   */
+  on(event, fn) {
+    const key = this.nextKey++;
+    const unsub = super.on(event, fn);
+    this.registrations.set(key, unsub);
+    return () => {
+      this.registrations.delete(key);
+      unsub();
+    };
+  }
+  /**
+   * Identical to `EventBus.once` but the listener is tracked so that
+   * `teardown()` will remove it automatically.
+   *
+   * Uses EventBus's public API directly to avoid triggering our own `on()`
+   * override (which would consume a key slot for the wrapper, then orphan
+   * our registration entry under a different key).
+   */
+  once(event, fn) {
+    const key = this.nextKey++;
+    const wrapper = (payload) => {
+      EventBus.prototype.off.call(this, event, wrapper);
+      fn(payload);
+    };
+    EventBus.prototype.on.call(this, event, wrapper);
+    const unsub = () => {
+      this.registrations.delete(key);
+      EventBus.prototype.off.call(this, event, wrapper);
+    };
+    this.registrations.set(key, unsub);
+    return unsub;
+  }
+  /**
+   * Identical to `EventBus.onPattern` but the listener is tracked so that
+   * `teardown()` will remove it automatically.
+   */
+  onPattern(pattern, fn) {
+    const key = this.nextKey++;
+    const unsub = super.onPattern(pattern, fn);
+    this.registrations.set(key, unsub);
+    return () => {
+      this.registrations.delete(key);
+      unsub();
+    };
+  }
+  /**
+   * Identical to `EventBus.onRegex` but the listener is tracked so that
+   * `teardown()` will remove it automatically.
+   */
+  onRegex(regex, fn) {
+    const key = this.nextKey++;
+    const unsub = super.onRegex(regex, fn);
+    this.registrations.set(key, unsub);
+    return () => {
+      this.registrations.delete(key);
+      unsub();
+    };
+  }
+  /**
+   * Remove every listener that was registered through this scoped bus.
+   * Idempotent — calling it multiple times is safe.
+   *
+   * Also available as `[Symbol.dispose]` for explicit resource management:
+   * ```ts
+   * using scope = new ScopedEventBus();
+   * scope.on('tool.executed', handler);
+   * // automatically teardown()'d when scope exits
+   * ```
+   */
+  teardown() {
+    for (const unsub of this.registrations.values()) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.registrations.clear();
+    this.clear();
+  }
+  /** Alias for `teardown()` — enables `using new ScopedEventBus()` in Node ≥ 22. */
+  [Symbol.dispose]() {
+    this.teardown();
+  }
+  /** Number of tracked registrations. */
+  get scopedListenerCount() {
+    return this.registrations.size;
+  }
+};
 function makePatternMatcher(pattern) {
   if (pattern === "*") return () => true;
   if (pattern.endsWith(".*")) {
@@ -1688,7 +1794,15 @@ var PATTERNS = [
     type: "stripe_key",
     regex: /(?<![A-Za-z0-9])sk_(?:live|test)_[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g
   },
-  { type: "twilio_sid", regex: /(?<![A-Za-z0-9])AC[a-f0-9]{32}(?![A-Za-z0-9])/g },
+  {
+    type: "twilio_sid",
+    regex: /(?<![A-Za-z0-9])AC[a-f0-9]{32}(?![A-Za-z0-9])/g
+  },
+  {
+    type: "telegram_bot_token",
+    // Telegram tokens are of the form  bot<digits>:<alphanum>  in URL paths
+    regex: /\/bot\d+:[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
+  },
   {
     type: "jwt",
     // Anchored: look for literal "eyJ" which is unambiguous for JWT header
@@ -1786,8 +1900,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat6 = await fsp2.stat(targetPath);
-      mode = stat6.mode & 511;
+      const stat8 = await fsp2.stat(targetPath);
+      mode = stat8.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -3827,8 +3941,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = path6.join(this.dir, `${id}.jsonl`);
-      const stat6 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat6.mtime.toISOString());
+      const stat8 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat8.mtime.toISOString());
       await fsp2.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -4495,6 +4609,16 @@ function labelOf(scope) {
 }
 
 // src/storage/config-store.ts
+function stripEphemeralFields(cfg) {
+  const env = cfg._envSource;
+  if (!env?.size) return cfg;
+  const out = { ...cfg };
+  for (const field of env) {
+    delete out[field];
+  }
+  delete out._envSource;
+  return out;
+}
 var DefaultConfigStore = class {
   current;
   watchers = /* @__PURE__ */ new Set();
@@ -4512,7 +4636,8 @@ var DefaultConfigStore = class {
     return ext ? ext : FROZEN_EMPTY;
   }
   update(partial) {
-    const next = deepFreeze(structuredClone({ ...this.current, ...partial }));
+    const scrubbed = stripEphemeralFields(partial);
+    const next = deepFreeze(structuredClone({ ...this.current, ...scrubbed }));
     if (next.version !== 1) {
       throw new Error(`ConfigStore.update: version must remain 1, got ${String(next.version)}`);
     }
@@ -4617,15 +4742,19 @@ var BEHAVIOR_DEFAULTS = {
 var ENV_MAP = {
   WRONGSTACK_PROVIDER: (c, v) => {
     c.provider = v;
+    (c._envSource ??= /* @__PURE__ */ new Set()).add("provider");
   },
   WRONGSTACK_MODEL: (c, v) => {
     c.model = v;
+    (c._envSource ??= /* @__PURE__ */ new Set()).add("model");
   },
   WRONGSTACK_API_KEY: (c, v) => {
     c.apiKey = v;
+    (c._envSource ??= /* @__PURE__ */ new Set()).add("apiKey");
   },
   WRONGSTACK_BASE_URL: (c, v) => {
     c.baseUrl = v;
+    (c._envSource ??= /* @__PURE__ */ new Set()).add("baseUrl");
   },
   WRONGSTACK_LOG_LEVEL: (c, v) => {
     if (!c.log) c.log = { level: "info" };
@@ -5219,9 +5348,149 @@ function matchIndex(plan, idOrIndex) {
   const lower = idOrIndex.toLowerCase();
   return plan.items.findIndex((it) => it.title.toLowerCase().includes(lower));
 }
+function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
+  const idx = matchIndex(plan, idOrIndex);
+  if (idx === -1) return null;
+  const item = plan.items[idx];
+  if (!item) return null;
+  let updatedPlan = plan;
+  if (item.status !== "done") {
+    updatedPlan = setPlanItemStatus(plan, idOrIndex, "in_progress");
+  }
+  const todos = [];
+  todos.push({
+    id: `todo_${Date.now()}_plan`,
+    content: item.title,
+    status: "in_progress",
+    activeForm: item.title
+  });
+  if (subtasks && subtasks.length > 0) {
+    for (const st of subtasks) {
+      todos.push({
+        id: `todo_${Date.now()}_${randomUUID().slice(0, 6)}`,
+        content: st,
+        status: "pending"
+      });
+    }
+  }
+  return { plan: updatedPlan, todos };
+}
 function attachPlanCheckpoint(_state, _filePath, _sessionId) {
   return () => void 0;
 }
+
+// src/storage/plan-templates.ts
+var templates = {
+  "new-feature": {
+    name: "new-feature",
+    description: "Standard workflow for adding a new feature",
+    category: "development",
+    items: [
+      { title: "Write specification / design doc", details: "Define scope, acceptance criteria, edge cases" },
+      { title: "Set up feature branch", details: "git checkout -b feature/..." },
+      { title: "Implement core logic", details: "TDD preferred \u2014 write tests first" },
+      { title: "Add unit tests", details: ">= 80% coverage for new code" },
+      { title: "Add integration tests", details: "End-to-end happy path + error paths" },
+      { title: "Update documentation", details: "README, API docs, changelog" },
+      { title: "Code review", details: "Self-review before requesting review" },
+      { title: "Merge and deploy", details: "CI green, tag release" }
+    ]
+  },
+  "bug-fix": {
+    name: "bug-fix",
+    description: "Systematic approach to fixing bugs",
+    category: "maintenance",
+    items: [
+      { title: "Reproduce the bug", details: "Minimal reproduction case" },
+      { title: "Root cause analysis", details: "Trace through logs, debugger" },
+      { title: "Write failing test", details: "Test must fail before fix" },
+      { title: "Implement fix", details: "Smallest possible change" },
+      { title: "Verify fix", details: "Test passes, reproduction no longer fails" },
+      { title: "Regression test", details: "Ensure no related tests broken" },
+      { title: "Document in changelog", details: "Brief description + issue link" }
+    ]
+  },
+  "refactor": {
+    name: "refactor",
+    description: "Safe refactoring workflow",
+    category: "maintenance",
+    items: [
+      { title: "Identify refactoring target", details: "Code smell, performance bottleneck, or tech debt" },
+      { title: "Ensure test coverage", details: "Existing tests must pass before and after" },
+      { title: "Write characterization tests", details: "Capture current behavior if tests weak" },
+      { title: "Apply refactoring", details: "Small steps, frequent commits" },
+      { title: "Run full test suite", details: "All tests must pass" },
+      { title: "Performance check", details: "Ensure no regression" },
+      { title: "Code review", details: "Explain the why, not just the what" }
+    ]
+  },
+  "release": {
+    name: "release",
+    description: "Preparing a new release",
+    category: "release",
+    items: [
+      { title: "Version bump", details: "package.json, lockfiles, tags" },
+      { title: "Update changelog", details: "All changes since last release" },
+      { title: "Run full test suite", details: "Unit + integration + e2e" },
+      { title: "Build artifacts", details: "Docker images, bundles, binaries" },
+      { title: "Staging smoke tests", details: "Deploy to staging, verify" },
+      { title: "Production deploy", details: "Blue-green or canary" },
+      { title: "Post-deploy verification", details: "Health checks, error rates" },
+      { title: "Announce release", details: "Slack, email, GitHub release notes" }
+    ]
+  },
+  "security-audit": {
+    name: "security-audit",
+    description: "Security review and hardening",
+    category: "infrastructure",
+    items: [
+      { title: "Dependency audit", details: "npm audit, Snyk, Dependabot alerts" },
+      { title: "Secret scan", details: "git-secrets, truffleHog, manual review" },
+      { title: "Access control review", details: "IAM, roles, least privilege" },
+      { title: "Input validation audit", details: "SQL injection, XSS, path traversal" },
+      { title: "Authentication review", details: "Session management, MFA, password policy" },
+      { title: "Logging and monitoring", details: "PII in logs, audit trails" },
+      { title: "Incident response plan", details: "Runbooks, contacts, escalation" }
+    ]
+  },
+  "onboarding": {
+    name: "onboarding",
+    description: "New developer onboarding checklist",
+    category: "infrastructure",
+    items: [
+      { title: "Repository access", details: "GitHub/GitLab permissions" },
+      { title: "Local environment setup", details: "Docker, dependencies, env files" },
+      { title: "Run tests locally", details: "Verify green suite" },
+      { title: "Read architecture docs", details: "ADR, README, onboarding guide" },
+      { title: "First commit", details: "Docs fix or small improvement" },
+      { title: "Pair programming session", details: "Walk through codebase with buddy" },
+      { title: "Deploy to staging", details: "Verify CI/CD access" }
+    ]
+  }
+};
+function listPlanTemplates() {
+  return Object.values(templates);
+}
+function getPlanTemplate(name) {
+  return templates[name];
+}
+function formatPlanTemplates() {
+  const cats = /* @__PURE__ */ new Map();
+  for (const t2 of Object.values(templates)) {
+    const arr = cats.get(t2.category) ?? [];
+    arr.push(t2);
+    cats.set(t2.category, arr);
+  }
+  const lines = ["Available plan templates:"];
+  for (const [cat, items] of cats) {
+    lines.push(`
+${cat}:`);
+    for (const t2 of items) {
+      lines.push(`  ${t2.name.padEnd(18)} \u2014 ${t2.description}`);
+    }
+  }
+  return lines.join("\n");
+}
 async function loadDirectorState(filePath) {
   let raw;
   try {
@@ -5237,15 +5506,48 @@ async function loadDirectorState(filePath) {
     return null;
   }
 }
+async function acquireDirectorStateLock(lockPath, processId = process.pid) {
+  let existing;
+  try {
+    existing = await fsp2.readFile(lockPath, "utf8");
+  } catch {
+  }
+  if (existing) {
+    try {
+      const lock2 = JSON.parse(existing);
+      try {
+        process.kill(lock2.pid, 0);
+        return false;
+      } catch {
+      }
+    } catch {
+    }
+  }
+  const lock = {
+    pid: processId,
+    hostname: __require("os").hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await atomicWrite(lockPath, JSON.stringify(lock), { mode: 384 });
+  return true;
+}
+async function releaseDirectorStateLock(lockPath) {
+  try {
+    await fsp2.unlink(lockPath);
+  } catch {
+  }
+}
 var DirectorStateCheckpoint = class {
   snapshot;
   filePath;
+  lockPath;
   timer = null;
   debounceMs;
   writing = false;
   rewriteRequested = false;
   constructor(filePath, init, debounceMs = 250) {
     this.filePath = filePath;
+    this.lockPath = `${filePath}.lock`;
     this.debounceMs = debounceMs;
     this.snapshot = {
       version: 1,
@@ -5255,10 +5557,36 @@ var DirectorStateCheckpoint = class {
       maxSpawns: init.maxSpawns,
       spawnDepth: init.spawnDepth,
       maxSpawnDepth: init.maxSpawnDepth,
+      directorBudget: init.directorBudget,
       subagents: [],
       tasks: []
     };
   }
+  /**
+   * Attempt to acquire the lock for this checkpoint. Call this before
+   * resuming a crashed director run. If it returns false, another
+   * director process is still running this fleet — do not resume.
+   */
+  async acquireLock() {
+    return acquireDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Release the lock on graceful shutdown. Call `flush()` first to ensure
+   * the final checkpoint state is on disk before removing the lock.
+   * Without this, the next resume will see a stale-lock and refuse.
+   */
+  async releaseLock() {
+    return releaseDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Resume from a snapshot previously loaded via `loadDirectorState()`.
+   * Use this when `--resume <runId>` is triggered — the snapshot has
+   * the full fleet state (subagents, tasks) from before the crash; the
+   * checkpoint continues from there.
+   */
+  resume(snapshot) {
+    this.snapshot = snapshot;
+  }
   current() {
     return this.snapshot;
   }
@@ -5346,6 +5674,7 @@ var DefaultPermissionPolicy = class {
   loaded = false;
   trustFile;
   yolo;
+  forceAllYolo;
   /**
    * Session-scoped "soft deny" map. When the user presses 'n' (block once),
    * the tool+pattern is added here. If the LLM retries in the same session,
@@ -5378,6 +5707,7 @@ var DefaultPermissionPolicy = class {
   constructor(opts) {
     this.trustFile = opts.trustFile;
     this.yolo = opts.yolo ?? false;
+    this.forceAllYolo = opts.forceAllYolo ?? false;
     this.promptDelegate = opts.promptDelegate;
   }
   /**
@@ -5397,6 +5727,14 @@ var DefaultPermissionPolicy = class {
   getYolo() {
     return this.yolo;
   }
+  /** Toggle force-all-YOLO at runtime. */
+  setForceAllYolo(enabled) {
+    this.forceAllYolo = enabled;
+  }
+  /** Check whether force-all-YOLO is active. */
+  getForceAllYolo() {
+    return this.forceAllYolo;
+  }
   async reload() {
     try {
       const raw = await fsp2.readFile(this.trustFile, "utf8");
@@ -5438,6 +5776,21 @@ var DefaultPermissionPolicy = class {
       return { permission: "auto", source: "trust" };
     }
     if (this.yolo) {
+      if (tool.riskTier === "destructive" && !this.forceAllYolo) {
+        if (this.promptDelegate) {
+          const decision = await this.promptDelegate(tool, input, subject ?? tool.name);
+          if (decision === "always") {
+            await this.trust({ tool: tool.name, pattern: subject ?? tool.name });
+            return { permission: "auto", source: "user", reason: "destructive yolo always-allowed" };
+          }
+          if (decision === "deny") {
+            await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
+            return { permission: "deny", source: "user", reason: "user denied destructive yolo" };
+          }
+          return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
+        }
+        return { permission: "confirm", source: "yolo_destructive", riskTier: "destructive", reason: "destructive tool needs explicit approval even in yolo mode" };
+      }
       return { permission: "auto", source: "yolo" };
     }
     if (tool.name === "write" && subject) {
@@ -7968,6 +8321,9 @@ function makeSpawnTool(director, roster) {
         if (err instanceof DirectorBudgetError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
         }
+        if (err instanceof DirectorCostCapError) {
+          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+        }
         return { error: err instanceof Error ? err.message : String(err) };
       }
     }
@@ -8105,6 +8461,65 @@ function makeFleetUsageTool(director) {
     }
   };
 }
+function makeFleetSessionTool(director) {
+  return {
+    name: "fleet_session",
+    description: "Read a subagent's JSONL transcript and extract its last assistant text, stop reason, and tool-use count. Use this to see what a running or timed-out subagent actually produced.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: { type: "string", description: "Subagent id to read the transcript of." },
+        /** Number of trailing lines to return (last N JSONL lines). Default: all. */
+        tail: { type: "number", description: "Number of trailing JSONL lines to return. Omit for the full transcript." }
+      },
+      required: ["subagentId"]
+    },
+    async execute(input) {
+      const i = input;
+      const result = await director.readSession(i.subagentId, i.tail);
+      if (!result) {
+        return {
+          error: `fleet_session: transcript unavailable for "${i.subagentId}". Is sessionsRoot configured?`
+        };
+      }
+      return result;
+    }
+  };
+}
+function makeFleetHealthTool(director) {
+  return {
+    name: "fleet_health",
+    description: "Per-subagent health report: budget pressure (pct of limits consumed), last activity timestamp, and current status. Use to decide whether to assign more work to a subagent or spawn a fresh one.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      const status = director.status();
+      const snapshot = director.snapshot();
+      const subagents = status.subagents ?? [];
+      const perSubagent = snapshot.perSubagent ?? {};
+      return {
+        subagents: subagents.map((s) => {
+          const usage = perSubagent[s.id];
+          return {
+            id: s.id,
+            status: s.status,
+            lastEventAt: usage?.lastEventAt,
+            // Budget pressure: fraction of each limit consumed if we have it.
+            // BudgetWarning events carry used/limit ratios; surface them here.
+            budgetPressure: {
+              iterations: usage?.iterations,
+              toolCalls: usage?.toolCalls,
+              costUsd: usage?.cost
+            }
+          };
+        })
+      };
+    }
+  };
+}
 
 // src/coordination/director.ts
 var DirectorBudgetError = class extends Error {
@@ -8121,6 +8536,20 @@ var DirectorBudgetError = class extends Error {
     this.observed = observed;
   }
 };
+var DirectorCostCapError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
+    );
+    this.name = "DirectorCostCapError";
+    this.kind = "max_cost_usd";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
 var Director = class {
   id;
   fleet;
@@ -8175,6 +8604,14 @@ var Director = class {
   /** Debounce timer for periodic manifest writes. */
   manifestTimer = null;
   manifestDebounceMs;
+  /** Fleet-wide cost cap. Infinity means no cap. */
+  maxCostUsd;
+  /** Max auto-extensions per subagent per budget kind before denying. */
+  maxBudgetExtensions;
+  /** Sessions root for direct subagent JSONL reads (fleet_session tool). */
+  sessionsRoot;
+  /** Director run id for JSONL path resolution. */
+  directorRunId;
   /** Resolves task descriptions back from `assign()` so completion events
    *  can also carry a human-readable title. */
   taskDescriptions = /* @__PURE__ */ new Map();
@@ -8201,12 +8638,17 @@ var Director = class {
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.maxCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 2;
+    this.sessionsRoot = opts.sessionsRoot;
+    this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
       directorRunId: this.id,
       maxSpawns: opts.maxSpawns,
       spawnDepth: this.spawnDepth,
-      maxSpawnDepth: this.maxSpawnDepth
-    }) : null;
+      maxSpawnDepth: this.maxSpawnDepth,
+      directorBudget: opts.directorBudget
+    }, opts.checkpointDebounceMs ?? 250) : null;
     if (this.sharedScratchpadPath) {
       void fsp2.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
     }
@@ -8267,7 +8709,7 @@ var Director = class {
       const payload = e.payload;
       const guardKey = `${e.subagentId}:${payload.kind}`;
       const prior = extendCounts.get(guardKey) ?? 0;
-      if (prior >= 2) {
+      if (prior >= this.maxBudgetExtensions) {
         payload.deny();
         extendCounts.delete(guardKey);
         return;
@@ -8328,6 +8770,12 @@ var Director = class {
     if (this.spawnCount >= this.maxSpawns) {
       throw new DirectorBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
     }
+    if (this.maxCostUsd < Number.POSITIVE_INFINITY) {
+      const totalCost = this.usage.snapshot().total?.cost ?? 0;
+      if (totalCost >= this.maxCostUsd) {
+        throw new DirectorCostCapError(this.maxCostUsd, totalCost);
+      }
+    }
     const result = await this.coordinator.spawn(config);
     this.spawnCount += 1;
     this.subagentMeta.set(result.subagentId, {
@@ -8507,6 +8955,7 @@ var Director = class {
     if (this.stateCheckpoint) {
       this.stateCheckpoint.setUsage(this.usage.snapshot());
       await this.stateCheckpoint.flush().catch((err) => this.logShutdownError("state_checkpoint_flush", err));
+      await this.stateCheckpoint.releaseLock().catch((err) => this.logShutdownError("state_checkpoint_lock_release", err));
     }
   }
   /**
@@ -8610,6 +9059,58 @@ var Director = class {
   completedResults() {
     return Array.from(this.completed.values());
   }
+  /**
+   * Inject a previously-saved checkpoint snapshot. Call this right after
+   * constructing a Director during a `--resume` run so the in-memory state
+   * (subagents, tasks, waiters) reflects the pre-crash reality instead of
+   * starting from a blank slate. The director then resumes from there —
+   * completing any in-flight tasks and ignoring tasks that already reached
+   * a terminal state in the prior run.
+   */
+  setCheckpointState(snapshot) {
+    this.stateCheckpoint?.resume(snapshot);
+  }
+  /**
+   * Read a subagent's JSONL transcript directly from disk (no bridge
+   * round-trip needed). Returns the last assistant text, stop reason,
+   * tool-use count, and line count — or null if the file is unavailable.
+   * Requires `sessionsRoot` to be set on construction.
+   */
+  async readSession(subagentId, tail) {
+    if (!this.sessionsRoot) return null;
+    const filePath = path6.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    let raw;
+    try {
+      raw = await fsp2.readFile(filePath, "utf8");
+    } catch {
+      return null;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const targetLines = tail ? lines.slice(-tail) : lines;
+    let lastAssistantText;
+    let lastStopReason;
+    let toolUses = 0;
+    for (const line of targetLines) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev.type === "assistant" && typeof ev.text === "string") {
+          lastAssistantText = ev.text;
+        } else if (ev.type === "stop" && ev.stopReason) {
+          lastStopReason = ev.stopReason;
+        } else if (ev.type === "tool_use") {
+          toolUses++;
+        }
+      } catch {
+      }
+    }
+    return {
+      lastAssistantText,
+      lastStopReason,
+      toolUsesObserved: toolUses,
+      events: targetLines.length,
+      path: filePath
+    };
+  }
   snapshot() {
     return this.usage.snapshot();
   }
@@ -8688,10 +9189,28 @@ var Director = class {
       makeRollUpTool(this),
       makeTerminateTool(this),
       makeFleetStatusTool(this),
-      makeFleetUsageTool(this)
+      makeFleetUsageTool(this),
+      makeFleetSessionTool(this),
+      makeFleetHealthTool(this)
     ];
     return t2;
   }
+  /**
+   * Attempt to acquire the checkpoint lock. Must be called before
+   * resuming — if another director process is alive, this returns
+   * false and the caller should not proceed with the resume.
+   */
+  async acquireCheckpointLock() {
+    return this.stateCheckpoint ? this.stateCheckpoint.acquireLock() : true;
+  }
+  /**
+   * Resume from a prior checkpoint snapshot (loaded via
+   * `loadDirectorState()`). Re-attach to the fleet mid-flight so
+   * subsequent spawn/assign calls update the checkpoint normally.
+   */
+  resumeFromCheckpoint(snapshot) {
+    this.stateCheckpoint?.resume(snapshot);
+  }
 };
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
@@ -8797,7 +9316,7 @@ function createDelegateTool(opts) {
         if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
           cfg.maxToolCalls = i.maxToolCalls;
         }
-        const SUBAGENT_TIMEOUT_BUFFER_MS = 3e4;
+        const SUBAGENT_TIMEOUT_BUFFER_MS = opts.subagentTimeoutBufferMs ?? 3e4;
         const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
           cfg.timeoutMs = desiredSubTimeout;
@@ -8849,7 +9368,7 @@ function createDelegateTool(opts) {
           toolCalls: result.toolCalls,
           durationMs: result.durationMs,
           ...partial ? { partial } : {},
-          ...hintForKind(errorKind, retryable, backoffMs) ? { hint: hintForKind(errorKind, retryable, backoffMs) } : {}
+          ...hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {}
         };
       } catch (err) {
         return {
@@ -8869,7 +9388,7 @@ function instantiateRosterConfig2(role, base) {
     id: `${role}-${randomUUID().slice(0, 8)}`
   };
 }
-function hintForKind(kind, retryable, backoffMs) {
+function hintForKind(kind, retryable, backoffMs, partial) {
   if (!kind) return void 0;
   switch (kind) {
     case "provider_rate_limit":
@@ -8885,16 +9404,40 @@ function hintForKind(kind, retryable, backoffMs) {
     case "budget_iterations":
     case "budget_tool_calls":
     case "budget_tokens":
-    case "budget_cost":
-      return "Subagent exhausted its budget. The coordinator may auto-extend; otherwise raise the matching `max*` field (e.g. maxToolCalls: 600) on the next delegate, or split the task.";
-    case "budget_timeout":
-      return "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+    case "budget_cost": {
+      const base = "Subagent exhausted its budget. The coordinator may auto-extend; otherwise raise the matching `max*` field (e.g. maxToolCalls: 600) on the next delegate, or split the task.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Partial output produced before budget hit:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
+    case "budget_timeout": {
+      const base = "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Partial output produced before timeout:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
     case "aborted_by_parent":
       return "Subagent was aborted (user Ctrl+C, parent unwound, or sibling failure cascade). Not retryable until the abort condition is resolved.";
     case "empty_response":
       return "Subagent ended its turn with no text and no tool calls. Almost always a prompt / config issue \u2014 clarify the task or check the model.";
-    case "tool_failed":
-      return "A tool inside the subagent returned ok:false. Inspect `partial.lastAssistantText` for the agent reasoning, then retry with corrected inputs.";
+    case "tool_failed": {
+      const base = "A tool inside the subagent returned ok:false. Retry with corrected inputs.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Agent reasoning before failure:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
     case "bridge_failed":
       return "Parent-child bridge transport failed. This is rare \u2014 restart the session and retry.";
     default:
@@ -9179,8 +9722,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path6.join(modesDir, entry);
-      const stat6 = await fsp2.stat(filePath);
-      if (!stat6.isFile()) continue;
+      const stat8 = await fsp2.stat(filePath);
+      if (!stat8.isFile()) continue;
       const content = await fsp2.readFile(filePath, "utf8");
       const id = path6.basename(entry, path6.extname(entry));
       modes.push({
@@ -12762,10 +13305,10 @@ var SkillInstaller = class {
           if (!resolved.startsWith(path6.resolve(destDir))) {
             throw new Error(`Path traversal detected in skill file: ${file}`);
           }
-          const stat6 = await fsp2.stat(srcPath);
-          if (stat6.size > MAX_SKILL_FILE_SIZE) {
+          const stat8 = await fsp2.stat(srcPath);
+          if (stat8.size > MAX_SKILL_FILE_SIZE) {
             throw new Error(
-              `Skill file "${file}" is too large (${(stat6.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
+              `Skill file "${file}" is too large (${(stat8.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
             );
           }
           await fsp2.mkdir(path6.dirname(destPath), { recursive: true });
@@ -13161,6 +13704,1841 @@ async function revertSnapshots(snapshots) {
   }
   return { revertedFiles, errors };
 }
+var MATCHERS = {
+  pnpmWorkspace: (files) => files.includes("pnpm-workspace.yaml"),
+  gradlew: (_files, dirs) => dirs.includes("gradlew"),
+  mavenWrapper: (_files, dirs) => dirs.includes(".mvn"),
+  dotnetSdk: (files) => files.some((f) => f.endsWith(".csproj") || f.endsWith(".fsproj")),
+  yarnConfig: (files) => files.includes(".yarnrc") || files.includes("yarn.config.js"),
+  notPoetryLock: (files) => !files.includes("poetry.lock")
+};
+var STACK_SIGNATURES = [
+  // Node.js variants - checked in order, first match wins
+  {
+    stack: "nodejs",
+    packageManager: "pnpm",
+    manifestFiles: ["package.json"],
+    lockFiles: ["pnpm-lock.yaml"],
+    secondarySignatures: (f) => MATCHERS.pnpmWorkspace(f)
+  },
+  {
+    stack: "nodejs",
+    packageManager: "bun",
+    manifestFiles: ["package.json"],
+    lockFiles: ["bun.lockb"]
+  },
+  {
+    stack: "nodejs",
+    packageManager: "yarn",
+    manifestFiles: ["package.json"],
+    lockFiles: ["yarn.lock"],
+    secondarySignatures: (f) => MATCHERS.yarnConfig(f)
+  },
+  {
+    stack: "nodejs",
+    packageManager: "npm",
+    manifestFiles: ["package.json"],
+    lockFiles: ["package-lock.json"]
+  },
+  // Python variants
+  {
+    stack: "python",
+    packageManager: "poetry",
+    manifestFiles: ["pyproject.toml"],
+    lockFiles: ["poetry.lock"]
+  },
+  {
+    stack: "python",
+    packageManager: "pip",
+    manifestFiles: ["requirements.txt", "setup.py"],
+    lockFiles: ["requirements.txt"]
+  },
+  {
+    stack: "python",
+    packageManager: "pip",
+    manifestFiles: ["pyproject.toml"],
+    lockFiles: [],
+    secondarySignatures: (f) => MATCHERS.notPoetryLock(f)
+  },
+  // Rust
+  {
+    stack: "rust",
+    packageManager: "cargo",
+    manifestFiles: ["Cargo.toml"],
+    lockFiles: ["Cargo.lock"]
+  },
+  // Go
+  {
+    stack: "go",
+    packageManager: "go",
+    manifestFiles: ["go.mod"],
+    lockFiles: ["go.sum"]
+  },
+  // Java variants
+  {
+    stack: "java",
+    packageManager: "gradle",
+    manifestFiles: ["build.gradle", "build.gradle.kts", "settings.gradle", "settings.gradle.kts"],
+    lockFiles: [],
+    secondarySignatures: (_f, d) => MATCHERS.gradlew(_f, d)
+  },
+  {
+    stack: "java",
+    packageManager: "maven",
+    manifestFiles: ["pom.xml"],
+    lockFiles: [],
+    secondarySignatures: (_f, d) => MATCHERS.mavenWrapper(_f, d)
+  },
+  // .NET
+  {
+    stack: "dotnet",
+    packageManager: "nuget",
+    manifestFiles: ["Directory.Build.props", "Directory.Packages.props"],
+    lockFiles: ["packages.lock.json"],
+    secondarySignatures: (f) => MATCHERS.dotnetSdk(f)
+  },
+  {
+    stack: "dotnet",
+    packageManager: "nuget",
+    manifestFiles: ["*.csproj", "*.fsproj", "*.xproj"],
+    lockFiles: [],
+    secondarySignatures: (f) => MATCHERS.dotnetSdk(f)
+  },
+  // PHP
+  {
+    stack: "php",
+    packageManager: "composer",
+    manifestFiles: ["composer.json"],
+    lockFiles: ["composer.lock"]
+  },
+  // Ruby
+  {
+    stack: "ruby",
+    packageManager: "bundler",
+    manifestFiles: ["Gemfile"],
+    lockFiles: ["Gemfile.lock"]
+  },
+  // C++
+  {
+    stack: "cpp",
+    packageManager: "cmake",
+    manifestFiles: ["CMakeLists.txt"],
+    lockFiles: [],
+    secondarySignatures: (f) => f.includes("CMakeCache.txt") || f.includes("CMakePresets.json")
+  },
+  // Swift
+  {
+    stack: "swift",
+    packageManager: "swiftpm",
+    manifestFiles: ["Package.swift"],
+    lockFiles: []
+  }
+];
+var MONOREPO_INDICATORS = {
+  pnpm: ["pnpm-workspace.yaml"],
+  npm: ["lerna.json", "nx.json"],
+  yarn: [],
+  bun: [],
+  cargo: [],
+  go: ["go.work"],
+  maven: [],
+  gradle: [],
+  nuget: ["Directory.Build.props"],
+  pip: [],
+  poetry: [],
+  bundler: [],
+  cmake: [],
+  swiftpm: [],
+  unknown: []
+};
+var TechStackDetector = class {
+  cachedResults = /* @__PURE__ */ new Map();
+  async detect(projectRoot) {
+    const cached = this.cachedResults.get(projectRoot);
+    if (cached) return cached;
+    const result = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      projectRoot,
+      detectedStacks: [],
+      isMonorepo: false,
+      workspaceConfigs: []
+    };
+    const entries = await readdir(projectRoot, { withFileTypes: true });
+    const files = entries.filter((e) => e.isFile()).map((e) => e.name);
+    const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    const detectedStacks = /* @__PURE__ */ new Set();
+    for (const signature of STACK_SIGNATURES) {
+      const detected = this.matchSignature(signature, files, dirs);
+      if (detected) {
+        if (detectedStacks.has(signature.stack)) continue;
+        detectedStacks.add(signature.stack);
+        result.detectedStacks.push(detected);
+      }
+    }
+    result.isMonorepo = this.detectMonorepo(result.detectedStacks, dirs, files);
+    if (result.isMonorepo) {
+      result.workspaceConfigs = this.findWorkspaceConfigs(result.detectedStacks, dirs, files);
+    }
+    this.cachedResults.set(projectRoot, result);
+    return result;
+  }
+  matchSignature(signature, files, _dirs) {
+    const manifestMatch = this.findMatchingManifest(signature.manifestFiles, files);
+    if (!manifestMatch) return null;
+    if (signature.lockFiles.length > 0 && signature.stack === "nodejs") {
+      const hasLockFile = signature.lockFiles.some((lock) => {
+        if (lock.includes("*")) {
+          const regex = new RegExp("^" + lock.replace("*", ".*") + "$");
+          return files.some((f) => regex.test(f));
+        }
+        return files.includes(lock);
+      });
+      if (!hasLockFile && signature.packageManager !== "npm") {
+        return null;
+      }
+    }
+    return {
+      stack: signature.stack,
+      packageManager: signature.packageManager,
+      manifestFile: manifestMatch,
+      dependencies: [],
+      projectPath: ""
+    };
+  }
+  findMatchingManifest(manifests, files) {
+    for (const manifest of manifests) {
+      if (manifest.includes("*")) {
+        const regex = new RegExp("^" + manifest.replace("*", ".*") + "$");
+        const match = files.find((f) => regex.test(f));
+        if (match) return match;
+      } else if (files.includes(manifest)) {
+        return manifest;
+      }
+    }
+    return null;
+  }
+  detectMonorepo(stacks, dirs, files) {
+    if (stacks.length > 1) return true;
+    if (stacks.some((s) => s.packageManager === "pnpm") && files.includes("pnpm-workspace.yaml")) {
+      return true;
+    }
+    for (const stack of stacks) {
+      const indicators = MONOREPO_INDICATORS[stack.packageManager];
+      if (indicators && indicators.some((ind) => files.includes(ind) || dirs.includes(ind))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  findWorkspaceConfigs(stacks, dirs, files) {
+    const configs = [];
+    for (const stack of stacks) {
+      const indicators = MONOREPO_INDICATORS[stack.packageManager];
+      if (indicators) {
+        configs.push(...indicators.filter((ind) => files.includes(ind) || dirs.includes(ind)));
+      }
+    }
+    return [...new Set(configs)];
+  }
+  clearCache() {
+    this.cachedResults.clear();
+  }
+};
+var defaultTechStackDetector = new TechStackDetector();
+
+// src/security-scanner/skill-generator.ts
+var DEFAULT_OPTIONS = {
+  includeSecrets: true,
+  includeInjection: true,
+  includeConfig: true,
+  includeDependencies: true,
+  severityThreshold: "medium"
+};
+var SkillGenerator = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  generate(techStack) {
+    const patterns = this.getPatternsForStack(techStack.stack);
+    const content = this.buildSkillContent(techStack, patterns);
+    const targetFiles = this.getTargetFilesForStack(techStack);
+    return {
+      name: `security-scanner-${techStack.stack}`,
+      description: `Security scanner for ${techStack.stack} projects`,
+      version: "1.0.0",
+      techStack: techStack.stack,
+      content,
+      patterns,
+      metadata: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        confidence: this.calculateConfidence(techStack),
+        targetFiles
+      }
+    };
+  }
+  getPatternsForStack(stack) {
+    const patterns = [];
+    const severityOrder = ["critical", "high", "medium", "low"];
+    const minIndex = severityOrder.indexOf(this.options.severityThreshold);
+    if (this.options.includeSecrets) {
+      const secretPatterns = this.getSecretPatterns(stack);
+      patterns.push(...secretPatterns.filter((p) => severityOrder.indexOf(p.severity) <= minIndex));
+    }
+    if (this.options.includeInjection) {
+      const injectionPatterns = this.getInjectionPatterns(stack);
+      patterns.push(...injectionPatterns.filter((p) => severityOrder.indexOf(p.severity) <= minIndex));
+    }
+    if (this.options.includeConfig) {
+      const configPatterns = this.getConfigPatterns(stack);
+      patterns.push(...configPatterns.filter((p) => severityOrder.indexOf(p.severity) <= minIndex));
+    }
+    return patterns;
+  }
+  getSecretPatterns(stack) {
+    const commonSecrets = {
+      id: "hardcoded-secrets",
+      name: "Hardcoded Secrets",
+      severity: "critical",
+      description: "Detects hardcoded API keys, tokens, passwords, and private keys",
+      patterns: [
+        /(?:api[_-]?key|apikey|api[_-]?secret)[^\w]*[=:]\s*["']([a-zA-Z0-9_-]{20,})["']/gi,
+        /(?:password|passwd|pwd)[^\w]*[=:]\s*["'][^"']{6,64}["']/gi,
+        /(?:secret|token|auth)[^\w]*[=:]\s*["'][a-zA-Z0-9_/-]{20,}["']/gi,
+        /-----BEGIN\s+(?:RSA|DSA|EC|OPENSSH)?\s+PRIVATE\s+KEY-----/g
+      ],
+      fileExtensions: [".ts", ".js", ".py", ".go", ".java", ".rb", ".php", ".env"],
+      falsePositiveMarkers: ["process.env", "process.argv", "process.env.NODE_ENV"],
+      remediation: "Use environment variables or a secrets manager. Never commit secrets to version control."
+    };
+    const stackSpecific = {
+      nodejs: [
+        {
+          id: "npmrc-credentials",
+          name: "npmrc Credentials",
+          severity: "high",
+          description: "Detects .npmrc authentication tokens",
+          patterns: [
+            // eslint-disable-next-line no-control-regex
+            /_auth\s*=\s*[a-zA-Z0-9+/]{20,}/g,
+            /registry\s*=\s*https:\/\/[a-zA-Z0-9.-]+\/auth/g
+          ],
+          fileExtensions: [".npmrc"],
+          falsePositiveMarkers: [],
+          remediation: "Use npm token from environment variable, not hardcoded in .npmrc"
+        }
+      ],
+      python: [
+        {
+          id: "python-secret-env",
+          name: "Python Environment Secrets",
+          severity: "high",
+          description: "Detects secrets loaded via os.environ in Python",
+          patterns: [
+            /os\.environ\[['"](?:API_KEY|SECRET|PASSWORD|TOKEN)/g,
+            /getenv\(['"](?:API_KEY|SECRET|PASSWORD|TOKEN)/g
+          ],
+          fileExtensions: [".py"],
+          falsePositiveMarkers: ["os.environ.get", "getenv(", "os.getenv"],
+          remediation: "Use python-dotenv or environment variable injection at runtime"
+        }
+      ],
+      rust: [
+        {
+          id: "rust-env-secrets",
+          name: "Rust Environment Secrets",
+          severity: "high",
+          description: "Detects env! macro with hardcoded secrets",
+          patterns: [/env!\s*\[['"](?:API_KEY|SECRET|PASSWORD|TOKEN)/g],
+          fileExtensions: [".rs"],
+          falsePositiveMarkers: [],
+          remediation: "Use std::env::var and handle MissingKeyError properly"
+        }
+      ],
+      go: [
+        {
+          id: "go-hardcoded-secret",
+          name: "Go Hardcoded Secrets",
+          severity: "critical",
+          description: "Detects hardcoded secrets in Go source",
+          patterns: [
+            /os\.Getenv\(['"](?:API_KEY|SECRET|PASSWORD|TOKEN)/g,
+            /"[a-zA-Z0-9/+=]{40,}"\s*(?:&&|\|\|)\s*err\s*!=\s*nil/g
+          ],
+          fileExtensions: [".go"],
+          falsePositiveMarkers: ["os.Getenv", "os.LookupEnv"],
+          remediation: "Use viper or os.Getenv with validation"
+        }
+      ],
+      java: [
+        {
+          id: "java-system-getenv",
+          name: "Java System.getenv",
+          severity: "medium",
+          description: "Detects System.getenv() usage which may expose secrets",
+          patterns: [/System\.getenv\(['"](?:API_KEY|SECRET|PASSWORD|TOKEN)/g],
+          fileExtensions: [".java"],
+          falsePositiveMarkers: [],
+          remediation: "Use a secrets manager or environment-specific config"
+        }
+      ],
+      dotnet: [
+        {
+          id: "dotnet-config-secrets",
+          name: ".NET Configuration Secrets",
+          severity: "high",
+          description: "Detects secrets in .NET Configuration managers",
+          patterns: [
+            /ConfigurationManager\.ConnectionStrings/g,
+            /ConfigurationManager\.AppSettings/g
+          ],
+          fileExtensions: [".cs", ".config"],
+          falsePositiveMarkers: [],
+          remediation: "Use Azure Key Vault or user secrets during development"
+        }
+      ]
+    };
+    return [commonSecrets, ...stackSpecific[stack] ?? []];
+  }
+  getInjectionPatterns(stack) {
+    const commonInjection = {
+      id: "command-injection",
+      name: "Command Injection",
+      severity: "critical",
+      description: "Detects shell command injection vulnerabilities",
+      patterns: [
+        /exec\s*\(\s*[`'"].*\$/g,
+        /system\s*\(\s*[`'"].*\$/g,
+        /shell_exec\s*\(\s*[`'"].*\$/g,
+        /exec\s*\(\s*\$/g
+      ],
+      fileExtensions: [".ts", ".js", ".php", ".py", ".rb"],
+      falsePositiveMarkers: ["escapeshellarg", "escapeshellcmd", "sanitize"],
+      remediation: "Use parameterized commands with argument arrays instead of string interpolation."
+    };
+    const stackSpecific = {
+      nodejs: [
+        {
+          id: "eval-injection",
+          name: "Eval Injection",
+          severity: "critical",
+          description: "Detects dangerous eval/Function usage with user input",
+          patterns: [
+            /eval\s*\(\s*(?:req|body|input|params|query)/g,
+            /new\s+Function\s*\(\s*(?:req|body|input|params|query)/g
+          ],
+          fileExtensions: [".ts", ".js"],
+          falsePositiveMarkers: ["JSON.parse"],
+          remediation: "Never eval user input. Use JSON.parse for data, or proper sandboxing."
+        },
+        {
+          id: "sql-injection-template",
+          name: "SQL Injection via Template",
+          severity: "critical",
+          description: "Detects SQL queries built with string concatenation",
+          patterns: [
+            /(?:query|execute|select)\s*\(\s*[`'"].*\+.*(?:req|body|params|query)/gi,
+            /\.query\s*\(\s*`.*\$\{/g
+          ],
+          fileExtensions: [".ts", ".js"],
+          falsePositiveMarkers: ["parameterized", "prepared", "bind"],
+          remediation: "Use parameterized queries or an ORM with proper query building."
+        },
+        {
+          id: "nosql-injection",
+          name: "NoSQL Injection",
+          severity: "high",
+          description: "Detects NoSQL query injection via user input",
+          patterns: [
+            /find\s*\(\s*\{.*\$where/g,
+            /collection\.(?:find|aggregate)\s*\([^)]*\$/g
+          ],
+          fileExtensions: [".ts", ".js"],
+          falsePositiveMarkers: [],
+          remediation: "Sanitize and validate all user input before NoSQL queries."
+        }
+      ],
+      python: [
+        {
+          id: "python-sql-injection",
+          name: "Python SQL Injection",
+          severity: "critical",
+          description: "Detects SQL queries built with string formatting",
+          patterns: [
+            /execute\s*\(\s*f?["'].*%.*/g,
+            /cursor\.execute\s*\([^)]*\+[^)]*\)/g
+          ],
+          fileExtensions: [".py"],
+          falsePositiveMarkers: ["%s", "%d", "?", "parameterized"],
+          remediation: "Use parameterized queries with cursor.execute(query, params)."
+        },
+        {
+          id: "pickle-deserialization",
+          name: "Pickle Deserialization",
+          severity: "critical",
+          description: "Detects insecure pickle deserialization",
+          patterns: [
+            /pickle\.load\s*\(/g,
+            /pickle\.loads\s*\(/g,
+            /unpickle\.load\s*\(/g
+          ],
+          fileExtensions: [".py"],
+          falsePositiveMarkers: [],
+          remediation: "Never unpickle data from untrusted sources. Use JSON or custom serialization."
+        }
+      ],
+      go: [
+        {
+          id: "go-sql-injection",
+          name: "Go SQL Injection",
+          severity: "critical",
+          description: "Detects SQL queries with string concatenation",
+          patterns: [
+            /db\.Query\s*\([^)]*\+[^)]*\)/g,
+            /QueryContext?\s*\([^)]*\+[^)]*\)/g
+          ],
+          fileExtensions: [".go"],
+          falsePositiveMarkers: ["$1", "$2", "?", "params"],
+          remediation: 'Use parameterized queries: db.QueryContext(ctx, "SELECT * FROM users WHERE id=?", userID)'
+        }
+      ],
+      java: [
+        {
+          id: "java-sql-injection",
+          name: "Java SQL Injection",
+          severity: "critical",
+          description: "Detects SQL with string concatenation in JDBC",
+          patterns: [
+            /createStatement\s*\(\s*\).*\.executeQuery\s*\([^)]*\+/g,
+            /Statement\s*\([^)]*\+/g
+          ],
+          fileExtensions: [".java"],
+          falsePositiveMarkers: ["PreparedStatement", "?"],
+          remediation: "Use PreparedStatement with parameters."
+        }
+      ],
+      rust: [
+        {
+          id: "rust-command-injection",
+          name: "Rust Command Injection",
+          severity: "critical",
+          description: "Detects Command::new with string interpolation",
+          patterns: [
+            /Command::new\s*\([^)]*\)\s*\.(?:arg|args)\s*\([^)]*\+/g,
+            /Command::from\s*\(/g
+          ],
+          fileExtensions: [".rs"],
+          falsePositiveMarkers: ["Command::new", "args\\("],
+          remediation: "Use Command::new(array).args(&[...]) to avoid shell injection."
+        }
+      ],
+      dotnet: [
+        {
+          id: "csharp-sql-injection",
+          name: "C# SQL Injection",
+          severity: "critical",
+          description: "Detects SQL with string concatenation in C#",
+          patterns: [
+            /SqlCommand\s*\([^)]*\+[^)]*\)/g,
+            /\.ExecuteQuery\s*\([^)]*\+[^)]*\)/g
+          ],
+          fileExtensions: [".cs"],
+          falsePositiveMarkers: ["parameters.Add", "@", "SqlParameter"],
+          remediation: "Use parameterized queries with SqlParameter."
+        }
+      ]
+    };
+    return [commonInjection, ...stackSpecific[stack] ?? []];
+  }
+  getConfigPatterns(stack) {
+    const commonConfig = [
+      {
+        id: "insecure-tls",
+        name: "Insecure TLS Configuration",
+        severity: "high",
+        description: "Detects disabled TLS verification or weak TLS settings",
+        patterns: [
+          /rejectUnauthorized\s*[:=]\s*false/g,
+          /secure\s*[:=]\s*false/g,
+          /ssl\s*[:=]\s*false/g,
+          /TLS\s*\[\s*['"]?1\.0['"]?\]/gi,
+          /InsecureRequestWarning\.disable/g
+        ],
+        fileExtensions: [".ts", ".js", ".py", ".go", ".java"],
+        falsePositiveMarkers: ["NODE_TLS_REJECT_UNAUTHORIZED"],
+        remediation: "Always verify TLS certificates in production. Use proper certificate stores."
+      },
+      {
+        id: "debug-enabled",
+        name: "Debug Mode Enabled",
+        severity: "medium",
+        description: "Detects debug flags that may expose sensitive information",
+        patterns: [
+          /debug\s*[:=]\s*true/g,
+          /DEBUG\s*[:=]\s*true/g,
+          /development\s*mode/g
+        ],
+        fileExtensions: [".ts", ".js", ".py", ".env", ".json"],
+        falsePositiveMarkers: ['process.env.NODE_ENV !== "production"', "if (process.env.DEBUG)"],
+        remediation: "Disable debug mode in production. Use proper log levels."
+      }
+    ];
+    return commonConfig;
+  }
+  getTargetFilesForStack(techStack) {
+    const filesByStack = {
+      nodejs: [
+        "**/*.ts",
+        "**/*.js",
+        "**/*.json",
+        "**/.env*",
+        "**/package.json",
+        "**/tsconfig.json"
+      ],
+      python: [
+        "**/*.py",
+        "**/requirements*.txt",
+        "**/setup.py",
+        "**/pyproject.toml",
+        "**/.env*"
+      ],
+      rust: ["**/*.rs", "**/Cargo.toml", "**/Cargo.lock"],
+      go: ["**/*.go", "**/go.mod", "**/go.sum"],
+      java: ["**/*.java", "**/pom.xml", "**/build.gradle", "**/*.properties"],
+      dotnet: ["**/*.cs", "**/*.csproj", "**/*.config", "**/appsettings.json"],
+      php: ["**/*.php", "**/.env*", "**/composer.json"],
+      ruby: ["**/*.rb", "**/Gemfile", "**/.env*"],
+      cpp: ["**/*.cpp", "**/*.hpp", "**/CMakeLists.txt"],
+      c: ["**/*.c", "**/*.h"],
+      kotlin: ["**/*.kt", "**/*.kts", "**/build.gradle.kts"],
+      swift: ["**/*.swift", "**/Package.swift"],
+      unknown: ["**/*"]
+    };
+    return filesByStack[techStack.stack] || filesByStack.unknown;
+  }
+  buildSkillContent(techStack, patterns) {
+    const lines = [
+      "---",
+      `name: security-scanner-${techStack.stack}`,
+      `description: |`,
+      `  Auto-generated security scanner for ${techStack.stack} projects.`,
+      `  Scans for secrets, injection vectors, and configuration issues.`,
+      `version: 1.0.0`,
+      "---",
+      "",
+      `# Security Scanner \u2014 ${techStack.stack.toUpperCase()}`,
+      "",
+      `Scans ${techStack.stack} codebase for security vulnerabilities.`,
+      "",
+      "## Scan Targets",
+      "",
+      "### Code Vulnerabilities",
+      patterns.filter((p) => p.fileExtensions.some((ext) => [".ts", ".js", ".py", ".go", ".java", ".cs", ".rs"].includes(ext))).map((p) => `- **${p.name}** (${p.severity}): ${p.description}`).join("\n"),
+      "",
+      "### Configuration Issues",
+      patterns.filter((p) => p.fileExtensions.some((ext) => [".json", ".yaml", ".yml", ".env", ".config"].includes(ext))).map((p) => `- **${p.name}** (${p.severity}): ${p.description}`).join("\n"),
+      "",
+      "## Severity Levels",
+      "",
+      "- **CRITICAL**: Remote code execution, SQL injection, hardcoded secrets",
+      "- **HIGH**: Command injection, XXE, authentication bypass",
+      "- **MEDIUM**: Information disclosure, weak crypto, debug mode",
+      "- **LOW**: Code quality issues, missing headers",
+      "",
+      "## Report Format",
+      "",
+      "```",
+      "## Security Scan Report",
+      "",
+      "### CRITICAL",
+      "1. **[CRITICAL]** `file:line` \u2014 Description",
+      "   ```",
+      "   // vulnerable code",
+      "   ```",
+      "   **Remediation**: Fix description",
+      "",
+      "### Summary",
+      "| Severity | Count |",
+      "|----------|-------|",
+      "| Critical | X     |",
+      "| High     | X     |",
+      "| Medium   | X     |",
+      "| Low      | X     |",
+      "```",
+      "",
+      "## Remediation",
+      "",
+      patterns.map((p) => `- **${p.name}**: ${p.remediation}`).join("\n")
+    ];
+    return {
+      type: "skill",
+      content: lines.join("\n")
+    };
+  }
+  calculateConfidence(techStack) {
+    let confidence = 0.7;
+    if (techStack.dependencies.length > 0) confidence += 0.1;
+    if (techStack.manifestFile) confidence += 0.1;
+    if (techStack.packageManager !== "unknown") confidence += 0.1;
+    return Math.min(confidence, 1);
+  }
+};
+var defaultSkillGenerator = new SkillGenerator();
+var DEFAULT_SCAN_OPTIONS = {
+  includeSecrets: true,
+  includeInjection: true,
+  includeConfig: true,
+  includeDependencies: true,
+  excludePaths: ["node_modules", "dist", ".git", "coverage", "build", "target"],
+  fileExtensions: [],
+  depth: "standard"
+};
+var SecurityScanner = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_SCAN_OPTIONS, ...options };
+  }
+  async scan(projectRoot, skill, techStack) {
+    const startTime = Date.now();
+    const findings = [];
+    const errors = [];
+    let scannedFiles = 0;
+    const targetExtensions = this.getTargetExtensions(skill, techStack);
+    const files = await this.gatherFiles(projectRoot, targetExtensions);
+    for (const file of files) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const fileFindings = this.scanFile(content, file, skill.patterns);
+        findings.push(...fileFindings);
+        scannedFiles++;
+      } catch (err) {
+        errors.push(`Failed to read ${file}: ${err}`);
+      }
+    }
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    findings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+    const summary = this.calculateSummary(findings);
+    const scanDurationMs = Date.now() - startTime;
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      projectRoot,
+      techStack,
+      findings,
+      summary,
+      scannedFiles,
+      scanDurationMs,
+      errors
+    };
+  }
+  async gatherFiles(root, extensions) {
+    const files = [];
+    const maxDepth = this.options.depth === "quick" ? 2 : this.options.depth === "deep" ? 20 : 5;
+    await this.gatherFilesRecursive(root, files, extensions, 0, maxDepth);
+    return files;
+  }
+  async gatherFilesRecursive(dir, files, extensions, currentDepth, maxDepth) {
+    if (currentDepth > maxDepth) return;
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (this.shouldExclude(entry.name)) continue;
+          await this.gatherFilesRecursive(fullPath, files, extensions, currentDepth + 1, maxDepth);
+        } else if (entry.isFile()) {
+          if (extensions.length === 0 || extensions.includes(extname(entry.name))) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  shouldExclude(name) {
+    return this.options.excludePaths.some(
+      (exclude) => name === exclude || name.startsWith(exclude + "/") || name.startsWith(exclude + "\\")
+    );
+  }
+  getTargetExtensions(skill, _techStack) {
+    if (this.options.fileExtensions.length > 0) {
+      return this.options.fileExtensions;
+    }
+    const extensions = /* @__PURE__ */ new Set();
+    for (const pattern of skill.patterns) {
+      for (const ext of pattern.fileExtensions) {
+        if (ext.startsWith(".")) {
+          extensions.add(ext.toLowerCase());
+        }
+      }
+    }
+    return [...extensions];
+  }
+  scanFile(content, filePath, patterns) {
+    const findings = [];
+    const lines = content.split("\n");
+    for (const pattern of patterns) {
+      if (!this.matchesCategory(pattern)) continue;
+      for (const regex of pattern.patterns) {
+        regex.lastIndex = 0;
+        for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+          const line = lines[lineNum];
+          if (!line) continue;
+          if (regex.test(line)) {
+            if (this.isFalsePositive(line, pattern.falsePositiveMarkers)) {
+              continue;
+            }
+            findings.push({
+              id: `${pattern.id}-${filePath}-${lineNum}`,
+              severity: pattern.severity,
+              category: this.getCategoryFromPattern(pattern),
+              title: pattern.name,
+              description: pattern.description,
+              file: relative(process.cwd(), filePath),
+              line: lineNum + 1,
+              snippet: line.trim(),
+              remediation: pattern.remediation,
+              patternId: pattern.id,
+              confidence: "high"
+            });
+          }
+        }
+      }
+    }
+    return findings;
+  }
+  matchesCategory(pattern) {
+    if (pattern.id.includes("secret") || pattern.id.includes("npmrc") || pattern.id.includes("env")) {
+      return this.options.includeSecrets;
+    }
+    if (pattern.id.includes("injection") || pattern.id.includes("sql") || pattern.id.includes("command") || pattern.id.includes("eval")) {
+      return this.options.includeInjection;
+    }
+    if (pattern.id.includes("config") || pattern.id.includes("tls") || pattern.id.includes("debug")) {
+      return this.options.includeConfig;
+    }
+    return true;
+  }
+  getCategoryFromPattern(pattern) {
+    if (pattern.id.includes("secret")) return "secrets";
+    if (pattern.id.includes("injection") || pattern.id.includes("sql") || pattern.id.includes("command")) return "injection";
+    if (pattern.id.includes("config") || pattern.id.includes("tls") || pattern.id.includes("debug")) return "config";
+    if (pattern.id.includes("dependency")) return "dependency";
+    return "filesystem";
+  }
+  isFalsePositive(line, markers) {
+    for (const marker of markers) {
+      if (line.includes(marker)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  calculateSummary(findings) {
+    return {
+      critical: findings.filter((f) => f.severity === "critical").length,
+      high: findings.filter((f) => f.severity === "high").length,
+      medium: findings.filter((f) => f.severity === "medium").length,
+      low: findings.filter((f) => f.severity === "low").length,
+      total: findings.length
+    };
+  }
+};
+var defaultSecurityScanner = new SecurityScanner();
+var DEFAULT_REPORT_OPTIONS = {
+  outputDir: "security-reports",
+  format: "markdown",
+  includeRemediation: true,
+  groupBySeverity: true
+};
+var ReportGenerator = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_REPORT_OPTIONS, ...options };
+  }
+  async generate(scanResult) {
+    await this.ensureOutputDir();
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `security-report-${timestamp}.${this.options.format}`;
+    const filepath = join(this.options.outputDir, filename);
+    let content;
+    switch (this.options.format) {
+      case "json":
+        content = this.generateJson(scanResult);
+        break;
+      case "html":
+        content = this.generateHtml(scanResult);
+        break;
+      default:
+        content = this.generateMarkdown(scanResult);
+    }
+    await writeFile(filepath, content, "utf-8");
+    return filepath;
+  }
+  async ensureOutputDir() {
+    try {
+      await stat(this.options.outputDir);
+    } catch {
+      const { mkdir: mkdir10 } = await import('fs/promises');
+      await mkdir10(this.options.outputDir, { recursive: true });
+    }
+  }
+  generateMarkdown(result) {
+    const lines = [];
+    lines.push("# Security Scan Report");
+    lines.push("");
+    lines.push(`**Generated:** ${new Date(result.timestamp).toLocaleString()}`);
+    lines.push(`**Project:** ${result.projectRoot}`);
+    lines.push(`**Tech Stack:** ${result.techStack.stack} (${result.techStack.packageManager})`);
+    lines.push(`**Scanned Files:** ${result.scannedFiles}`);
+    lines.push(`**Scan Duration:** ${result.scanDurationMs}ms`);
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("");
+    lines.push("| Severity | Count |");
+    lines.push("|----------|-------|");
+    lines.push(`| \u{1F534} Critical | ${result.summary.critical} |`);
+    lines.push(`| \u{1F7E0} High | ${result.summary.high} |`);
+    lines.push(`| \u{1F7E1} Medium | ${result.summary.medium} |`);
+    lines.push(`| \u{1F7E2} Low | ${result.summary.low} |`);
+    lines.push(`| **Total** | **${result.summary.total}** |`);
+    lines.push("");
+    if (this.options.groupBySeverity) {
+      const severityGroups = this.groupBySeverity(result.findings);
+      for (const severity of ["critical", "high", "medium", "low"]) {
+        const findings = severityGroups[severity] ?? [];
+        if (findings.length === 0) continue;
+        const emoji = severity === "critical" ? "\u{1F534}" : severity === "high" ? "\u{1F7E0}" : severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+        lines.push(`## ${emoji} ${severity.toUpperCase()} (${findings.length})`);
+        lines.push("");
+        for (const finding of findings) {
+          lines.push(this.formatFinding(finding));
+        }
+        lines.push("");
+      }
+    } else {
+      const categoryGroups = this.groupByCategory(result.findings);
+      for (const [category, findings] of Object.entries(categoryGroups)) {
+        lines.push(`## ${category.toUpperCase()} (${findings.length})`);
+        lines.push("");
+        for (const finding of findings) {
+          lines.push(this.formatFinding(finding));
+        }
+        lines.push("");
+      }
+    }
+    if (result.errors.length > 0) {
+      lines.push("## Scan Errors");
+      lines.push("");
+      for (const error of result.errors) {
+        lines.push(`- ${error}`);
+      }
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push(`*Report generated by WrongStack Security Scanner*`);
+    return lines.join("\n");
+  }
+  formatFinding(finding) {
+    const lines = [];
+    lines.push(`### ${finding.title}`);
+    lines.push("");
+    lines.push(`**File:** \`${finding.file}${finding.line ? `:${finding.line}` : ""}\``);
+    lines.push(`**Severity:** ${finding.severity.toUpperCase()}`);
+    lines.push(`**Category:** ${finding.category}`);
+    lines.push("");
+    if (finding.snippet) {
+      lines.push("```");
+      lines.push(finding.snippet);
+      lines.push("```");
+      lines.push("");
+    }
+    if (this.options.includeRemediation) {
+      lines.push(`**Remediation:** ${finding.remediation}`);
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+    return lines.join("\n");
+  }
+  groupBySeverity(findings) {
+    const groups = {
+      critical: [],
+      high: [],
+      medium: [],
+      low: []
+    };
+    for (const finding of findings) {
+      const group = groups[finding.severity];
+      if (group) {
+        group.push(finding);
+      }
+    }
+    return groups;
+  }
+  groupByCategory(findings) {
+    const groups = {};
+    for (const finding of findings) {
+      const group = groups[finding.category] ?? (groups[finding.category] = []);
+      group.push(finding);
+    }
+    return groups;
+  }
+  generateJson(result) {
+    return JSON.stringify(
+      {
+        meta: {
+          timestamp: result.timestamp,
+          projectRoot: result.projectRoot,
+          techStack: result.techStack,
+          scannedFiles: result.scannedFiles,
+          scanDurationMs: result.scanDurationMs
+        },
+        summary: result.summary,
+        findings: result.findings,
+        errors: result.errors
+      },
+      null,
+      2
+    );
+  }
+  generateHtml(result) {
+    const severityColors = {
+      critical: "#dc2626",
+      high: "#ea580c",
+      medium: "#ca8a04",
+      low: "#16a34a"
+    };
+    const rows = result.findings.map(
+      (f) => `
+      <tr>
+        <td style="color: ${severityColors[f.severity]}; font-weight: bold;">${f.severity.toUpperCase()}</td>
+        <td>${f.category}</td>
+        <td>${f.title}</td>
+        <td><code>${f.file}${f.line ? `:${f.line}` : ""}</code></td>
+        <td>${f.remediation}</td>
+      </tr>
+    `
+    ).join("");
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Security Scan Report - ${new Date(result.timestamp).toLocaleDateString()}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 2rem; }
+    table { border-collapse: collapse; width: 100%; }
+    th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+    th { background: #f5f5f5; }
+    code { background: #f0f0f0; padding: 2px 4px; }
+  </style>
+</head>
+<body>
+  <h1>Security Scan Report</h1>
+  <p><strong>Generated:</strong> ${new Date(result.timestamp).toLocaleString()}</p>
+  <p><strong>Project:</strong> ${result.projectRoot}</p>
+  <p><strong>Tech Stack:</strong> ${result.techStack.stack} (${result.techStack.packageManager})</p>
+
+  <h2>Summary</h2>
+  <ul>
+    <li>\u{1F534} Critical: ${result.summary.critical}</li>
+    <li>\u{1F7E0} High: ${result.summary.high}</li>
+    <li>\u{1F7E1} Medium: ${result.summary.medium}</li>
+    <li>\u{1F7E2} Low: ${result.summary.low}</li>
+  </ul>
+
+  <h2>Findings</h2>
+  <table>
+    <tr>
+      <th>Severity</th>
+      <th>Category</th>
+      <th>Title</th>
+      <th>Location</th>
+      <th>Remediation</th>
+    </tr>
+    ${rows}
+  </table>
+</body>
+</html>
+    `.trim();
+  }
+};
+var defaultReportGenerator = new ReportGenerator();
+var DEFAULT_OPTIONS2 = {
+  gitignorePath: ".gitignore",
+  entries: ["security-reports/", "security-reports/*"]
+};
+var GitignoreUpdater = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS2, ...options };
+  }
+  async update() {
+    const added = [];
+    const existing = [];
+    const errors = [];
+    try {
+      const content = await readFile(this.options.gitignorePath, "utf-8");
+      const lines = new Set(content.split(/\r?\n/).map((l) => l.trim()));
+      for (const entry of this.options.entries) {
+        if (lines.has(entry)) {
+          existing.push(entry);
+        } else {
+          lines.add(entry);
+          added.push(entry);
+        }
+      }
+      if (added.length > 0) {
+        const newContent = [...lines].filter(Boolean).join("\n") + "\n";
+        await writeFile(this.options.gitignorePath, newContent, "utf-8");
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        const content = this.options.entries.join("\n") + "\n";
+        await writeFile(this.options.gitignorePath, content, "utf-8");
+        added.push(...this.options.entries);
+      } else {
+        errors.push(`Failed to update .gitignore: ${err}`);
+      }
+    }
+    return { added, existing, errors };
+  }
+  async isEntryIgnored(entry) {
+    try {
+      const content = await readFile(this.options.gitignorePath, "utf-8");
+      const lines = content.split(/\r?\n/).map((l) => l.trim());
+      return lines.includes(entry);
+    } catch {
+      return false;
+    }
+  }
+};
+var defaultGitignoreUpdater = new GitignoreUpdater();
+var NETWORK_ERR_RE2 = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
+var SecurityScannerOrchestrator = class {
+  constructor(retryPolicy, errorHandler) {
+    this.retryPolicy = retryPolicy;
+    this.errorHandler = errorHandler;
+  }
+  retryPolicy;
+  errorHandler;
+  detector = defaultTechStackDetector;
+  reportGenerator = defaultReportGenerator;
+  gitignoreUpdater = defaultGitignoreUpdater;
+  /**
+   * Wraps provider.complete with retry logic using the injected RetryPolicy.
+   */
+  async completeWithRetry(provider, request, abortController, attempt = 0) {
+    const signal = abortController.signal;
+    try {
+      return await provider.complete(request, { signal });
+    } catch (err) {
+      if (signal.aborted) throw err;
+      const isProviderErr = err instanceof ProviderError;
+      const policy = this.retryPolicy;
+      const errAsErr = isProviderErr ? err : err instanceof Error ? err : new Error(String(err));
+      if (!policy || !isProviderErr && !NETWORK_ERR_RE2.test(errAsErr.message)) {
+        throw err;
+      }
+      const canRetry = policy.shouldRetry(errAsErr, attempt);
+      if (!canRetry) throw err;
+      if (this.errorHandler) {
+        const classified = this.errorHandler.classify(err);
+        if (!classified.retryable) throw err;
+      }
+      const delay = Math.round(policy.delayMs(attempt));
+      const status = isProviderErr ? err.status : 0;
+      console.warn(`[SecurityScanner] retry ${attempt + 1} after ${delay}ms (status=${status}) \u2014 ${errAsErr.message}`);
+      await new Promise((resolve5) => setTimeout(resolve5, delay));
+      return this.completeWithRetry(provider, request, abortController, attempt + 1);
+    }
+  }
+  /**
+   * Run full security scan with LLM assistance.
+   * Accepts a full Context (active agent run) or just provider+model (pre-agent session).
+   */
+  async run(ctx, options) {
+    const { projectRoot, reportOptions, skipGitignore, model: explicitModel } = options;
+    const provider = "provider" in ctx ? ctx.provider : ctx;
+    const model = explicitModel ?? ("model" in ctx ? ctx.model : void 0);
+    const detectionResult = await this.detector.detect(projectRoot);
+    if (detectionResult.detectedStacks.length === 0) {
+      throw new Error(`No supported tech stack detected in ${projectRoot}`);
+    }
+    const techStack = detectionResult.detectedStacks[0];
+    const generatedSkill = await this.generateSkillLLM(provider, model, projectRoot, techStack);
+    const scanResult = await this.scanWithLLM(provider, model, projectRoot, generatedSkill, techStack, options);
+    const synthesizedReport = await this.synthesizeReportLLM(provider, model, projectRoot, techStack, scanResult);
+    const reportPath = await this.writeReport(synthesizedReport, reportOptions);
+    let gitignoreResult;
+    if (!skipGitignore) {
+      gitignoreResult = await this.gitignoreUpdater.update();
+    }
+    return {
+      detectionResult,
+      generatedSkill,
+      scanResult,
+      reportPath,
+      synthesizedReport,
+      gitignoreResult
+    };
+  }
+  /**
+   * Generate a project-specific security skill using LLM.
+   * The LLM analyzes the project structure and creates tailored security patterns.
+   */
+  async generateSkillLLM(provider, model, projectRoot, techStack) {
+    const projectInfo = await this.gatherProjectInfo(projectRoot, techStack);
+    const prompt = `You are a security expert generating a customized security scanning skill for a specific project.
+
+Analyze the following project and generate a detailed security skill with:
+1. Project-specific vulnerability patterns based on the tech stack and structure
+2. Language/framework specific security concerns
+3. Common attack vectors for this type of application
+4. File patterns to scan
+
+## Project Information:
+${projectInfo}
+
+## Tech Stack:
+- Language: ${techStack.stack}
+- Package Manager: ${techStack.packageManager}
+- Manifest: ${techStack.manifestFile}
+
+## Dependencies (first 20):
+${techStack.dependencies.slice(0, 20).map((d) => `- ${d.name}@${d.version}`).join("\n")}
+
+## Your Task:
+Generate a JSON security skill with the following structure:
+{
+  "name": "security-scanner-${techStack.stack}",
+  "description": "Custom security scanner for this project",
+  "techStack": "${techStack.stack}",
+  "patterns": [
+    {
+      "id": "unique-pattern-id",
+      "name": "Pattern Name",
+      "severity": "critical|high|medium|low",
+      "description": "What this detects",
+      "fileExtensions": [".ts", ".js"],
+      "remediation": "How to fix"
+    }
+  ],
+  "targetFiles": ["**/*.ts", "**/*.js"],
+  "scanInstructions": "Detailed instructions for scanning this codebase"
+}
+
+Focus on:
+- ${techStack.stack === "nodejs" ? "Node.js specific: eval, prototype pollution, npm script injection, express middleware issues, passport.js misconfigs" : ""}
+- ${techStack.stack === "python" ? "Python specific: pickle deserialization, SQL injection in ORMs, template injection, insecure Django/Flask settings" : ""}
+- Common: hardcoded secrets, SQL injection, command injection, XSS, path traversal, XXE
+
+Return ONLY the JSON object, no markdown, no explanation.`;
+    const request = {
+      model: model ?? "unknown",
+      system: [{ type: "text", text: "You are a security expert. Return ONLY valid JSON." }],
+      messages: [{ role: "user", content: prompt }],
+      maxTokens: 4096
+    };
+    try {
+      const abortController = new AbortController();
+      const response = await this.completeWithRetry(provider, request, abortController);
+      const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        const sanitized = sanitizeJsonString(jsonMatch[0]) || jsonMatch[0];
+        const skillData = JSON.parse(sanitized);
+        return {
+          name: skillData.name || `security-scanner-${techStack.stack}`,
+          description: skillData.description || `Security scanner for ${techStack.stack}`,
+          version: "1.0.0",
+          techStack: techStack.stack,
+          content: { type: "skill", content: JSON.stringify(skillData, null, 2) },
+          patterns: skillData.patterns || [],
+          metadata: {
+            generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            confidence: 0.85,
+            targetFiles: skillData.targetFiles || []
+          }
+        };
+      }
+    } catch (err) {
+      console.error("LLM skill generation failed, using fallback:", err);
+    }
+    return this.generateFallbackSkill(techStack);
+  }
+  /**
+   * Scan code using LLM with the generated skill as context.
+   * The LLM analyzes files and reports security findings.
+   */
+  async scanWithLLM(provider, model, projectRoot, skill, techStack, options) {
+    const startTime = Date.now();
+    const findings = [];
+    const errors = [];
+    let scannedFiles = 0;
+    const files = await this.gatherFiles(projectRoot, skill.metadata.targetFiles, options.scanOptions?.depth || "standard");
+    const batchSize = 10;
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      const batchFindings = await this.scanFileBatchLLM(provider, model, batch, skill, techStack);
+      findings.push(...batchFindings);
+      scannedFiles += batch.length;
+    }
+    const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    findings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+    const summary = {
+      critical: findings.filter((f) => f.severity === "critical").length,
+      high: findings.filter((f) => f.severity === "high").length,
+      medium: findings.filter((f) => f.severity === "medium").length,
+      low: findings.filter((f) => f.severity === "low").length,
+      total: findings.length
+    };
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      projectRoot,
+      techStack,
+      findings,
+      summary,
+      scannedFiles,
+      scanDurationMs: Date.now() - startTime,
+      errors
+    };
+  }
+  /**
+   * Scan a batch of files using LLM.
+   */
+  async scanFileBatchLLM(provider, model, files, skill, techStack) {
+    const fileContents = [];
+    for (const file of files) {
+      try {
+        const content = await readFile(file, "utf-8");
+        const relativePath = relative(process.cwd(), file);
+        fileContents.push(`
+=== ${relativePath} ===
+${content.slice(0, 2e3)}`);
+      } catch {
+      }
+    }
+    if (fileContents.length === 0) return [];
+    const prompt = `You are a security expert analyzing code for vulnerabilities.
+
+## Security Patterns to Detect (from generated skill):
+${skill.patterns.map((p) => `- ${p.name} (${p.severity}): ${p.description}`).join("\n")}
+
+## Files to Analyze:
+${fileContents.join("\n")}
+
+## Your Task:
+Analyze each file for security vulnerabilities matching the patterns above.
+For each finding, provide:
+1. File path (relative path from === markers)
+2. Line number if identifiable
+3. Severity (critical/high/medium/low)
+4. Category (secrets/injection/config/dependency)
+5. Description of the issue
+6. Code snippet showing the vulnerability
+7. Remediation steps
+
+Return a JSON array of findings:
+[
+  {
+    "file": "path/to/file.ts",
+    "line": 42,
+    "severity": "high",
+    "category": "injection",
+    "title": "SQL Injection Risk",
+    "description": "...",
+    "snippet": "actual code...",
+    "remediation": "..."
+  }
+]
+
+Return ONLY the JSON array. If no issues found, return [].`;
+    try {
+      const request = {
+        model: model ?? "unknown",
+        system: [{ type: "text", text: "You are a security expert. Return ONLY valid JSON." }],
+        messages: [{ role: "user", content: prompt }],
+        maxTokens: 4096
+      };
+      const abortController = new AbortController();
+      const response = await this.completeWithRetry(provider, request, abortController);
+      const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const jsonMatch = text.match(/\[[\s\S]*\]/);
+      if (jsonMatch) {
+        const sanitized = sanitizeJsonString(jsonMatch[0]) || jsonMatch[0];
+        const parsed = JSON.parse(sanitized);
+        return parsed.map((item, idx) => ({
+          id: `llm-finding-${idx}-${Date.now()}`,
+          severity: item.severity,
+          category: item.category || "injection",
+          title: item.title,
+          description: item.description,
+          file: item.file,
+          line: item.line,
+          snippet: item.snippet,
+          remediation: item.remediation,
+          patternId: "llm-analysis",
+          confidence: "high"
+        }));
+      }
+    } catch (err) {
+      console.error("LLM scan batch failed:", err);
+    }
+    return [];
+  }
+  /**
+   * Synthesize a comprehensive security report using LLM.
+   */
+  async synthesizeReportLLM(provider, model, projectRoot, techStack, scanResult) {
+    const prompt = `You are a security expert writing a comprehensive security report.
+
+## Scan Results:
+- Scanned Files: ${scanResult.scannedFiles}
+- Total Findings: ${scanResult.summary.total}
+- Critical: ${scanResult.summary.critical}
+- High: ${scanResult.summary.high}
+- Medium: ${scanResult.summary.medium}
+- Low: ${scanResult.summary.low}
+
+## Detailed Findings:
+${scanResult.findings.map((f, i) => `
+${i + 1}. [${f.severity.toUpperCase()}] ${f.title}
+   File: ${f.file}${f.line ? `:${f.line}` : ""}
+   Category: ${f.category}
+   Description: ${f.description}
+   ${f.snippet ? `Code: \`\`\`
+${f.snippet}
+\`\`\`` : ""}
+   Remediation: ${f.remediation}
+`).join("\n")}
+
+## Project:
+- Root: ${projectRoot}
+- Tech Stack: ${techStack.stack} (${techStack.packageManager})
+
+## Your Task:
+Write a comprehensive markdown security report with:
+1. Executive Summary (overall security posture)
+2. Critical Issues (with detailed analysis and remediation)
+3. High Priority Issues
+4. Medium Priority Issues
+5. Low Priority / Informational
+6. Security Recommendations (prioritized action items)
+7. Summary Table
+
+Format with proper markdown, emojis for severity, and actionable remediation steps.
+
+Be specific about the vulnerabilities found and how to fix them.`;
+    try {
+      const request = {
+        model: model ?? "unknown",
+        system: [{ type: "text", text: "You are a security expert writing detailed reports." }],
+        messages: [{ role: "user", content: prompt }],
+        maxTokens: 8192
+      };
+      const abortController = new AbortController();
+      const response = await this.completeWithRetry(provider, request, abortController);
+      return response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+    } catch (err) {
+      console.error("LLM report synthesis failed:", err);
+      return this.generateBasicReport(projectRoot, techStack, scanResult);
+    }
+  }
+  /**
+   * Generate a basic fallback report when LLM synthesis fails.
+   */
+  generateBasicReport(projectRoot, techStack, scanResult) {
+    const lines = [];
+    lines.push("# Security Scan Report");
+    lines.push("");
+    lines.push(`**Generated:** ${new Date(scanResult.timestamp).toLocaleString()}`);
+    lines.push(`**Project:** ${projectRoot}`);
+    lines.push(`**Tech Stack:** ${techStack.stack} (${techStack.packageManager})`);
+    lines.push(`**Scanned Files:** ${scanResult.scannedFiles}`);
+    lines.push("");
+    lines.push("## Summary");
+    lines.push("");
+    lines.push("| Severity | Count |");
+    lines.push("|----------|-------|");
+    lines.push(`| \u{1F534} Critical | ${scanResult.summary.critical} |`);
+    lines.push(`| \u{1F7E0} High | ${scanResult.summary.high} |`);
+    lines.push(`| \u{1F7E1} Medium | ${scanResult.summary.medium} |`);
+    lines.push(`| \u{1F7E2} Low | ${scanResult.summary.low} |`);
+    lines.push("");
+    for (const finding of scanResult.findings) {
+      const emoji = finding.severity === "critical" ? "\u{1F534}" : finding.severity === "high" ? "\u{1F7E0}" : finding.severity === "medium" ? "\u{1F7E1}" : "\u{1F7E2}";
+      lines.push(`## ${emoji} ${finding.title}`);
+      lines.push("");
+      lines.push(`**File:** \`${finding.file}${finding.line ? `:${finding.line}` : ""}\``);
+      lines.push(`**Severity:** ${finding.severity.toUpperCase()}`);
+      lines.push(`**Category:** ${finding.category}`);
+      lines.push("");
+      if (finding.snippet) {
+        lines.push("```");
+        lines.push(finding.snippet);
+        lines.push("```");
+        lines.push("");
+      }
+      lines.push(`**Remediation:** ${finding.remediation}`);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Write synthesized report to file.
+   */
+  async writeReport(content, reportOptions) {
+    const outputDir = reportOptions?.outputDir || "security-reports";
+    const format = reportOptions?.format || "markdown";
+    try {
+      await mkdir(outputDir, { recursive: true });
+    } catch {
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `security-report-${timestamp}.${format}`;
+    const filepath = join(outputDir, filename);
+    await writeFile(filepath, content, "utf-8");
+    return filepath;
+  }
+  /**
+   * Gather project info for skill generation.
+   */
+  async gatherProjectInfo(projectRoot, techStack) {
+    const info = [];
+    const keyFiles = [
+      "package.json",
+      "tsconfig.json",
+      ".env.example",
+      "README.md",
+      "CONTRIBUTING.md"
+    ];
+    for (const file of keyFiles) {
+      try {
+        const content = await readFile(join(projectRoot, file), "utf-8");
+        const displayName = file === "README.md" || file === "CONTRIBUTING.md" ? "README" : file;
+        info.push(`
+--- ${displayName} ---
+${content.slice(0, 1e3)}`);
+      } catch {
+      }
+    }
+    try {
+      const entries = await readdir(projectRoot, { withFileTypes: true });
+      const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).slice(0, 20);
+      info.push(`
+--- Project Directories ---
+${dirs.join(", ")}`);
+    } catch {
+    }
+    return info.join("\n");
+  }
+  /**
+   * Gather files to scan based on patterns.
+   */
+  async gatherFiles(root, patterns, depth) {
+    const files = [];
+    const maxDepth = depth === "quick" ? 2 : depth === "deep" ? 20 : 5;
+    const extensions = [".ts", ".js", ".jsx", ".tsx", ".py", ".go", ".java", ".cs", ".rs"];
+    await this.gatherFilesRecursive(root, files, extensions, 0, maxDepth);
+    return files;
+  }
+  async gatherFilesRecursive(dir, files, extensions, currentDepth, maxDepth) {
+    if (currentDepth > maxDepth) return;
+    try {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const name = entry.name;
+          if (name === "node_modules" || name === "dist" || name === "build" || name === ".git" || name === "coverage" || name.startsWith(".")) continue;
+          await this.gatherFilesRecursive(
+            join(dir, entry.name),
+            files,
+            extensions,
+            currentDepth + 1,
+            maxDepth
+          );
+        } else if (entry.isFile()) {
+          const ext = entry.name.lastIndexOf(".");
+          if (ext > 0 && extensions.includes(entry.name.slice(ext))) {
+            files.push(join(dir, entry.name));
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Generate fallback skill when LLM fails.
+   */
+  generateFallbackSkill(techStack) {
+    return {
+      name: `security-scanner-${techStack.stack}`,
+      description: `Security scanner for ${techStack.stack} projects`,
+      version: "1.0.0",
+      techStack: techStack.stack,
+      content: { type: "skill", content: "Fallback static skill" },
+      patterns: [
+        {
+          id: "hardcoded-secrets",
+          name: "Hardcoded Secrets",
+          severity: "critical",
+          description: "Detects hardcoded API keys, tokens, passwords",
+          patterns: [],
+          fileExtensions: [".ts", ".js", ".env"],
+          falsePositiveMarkers: [],
+          remediation: "Use environment variables"
+        }
+      ],
+      metadata: {
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        confidence: 0.5,
+        targetFiles: [`**/*.${techStack.stack === "nodejs" ? "ts" : techStack.stack === "python" ? "py" : "ts"}`]
+      }
+    };
+  }
+  /**
+   * Quick scan - legacy compatibility.
+   * NOTE: This won't use LLM as it doesn't have access to ctx.
+   */
+  async quickScan(projectRoot) {
+    const detectionResult = await this.detector.detect(projectRoot);
+    if (detectionResult.detectedStacks.length === 0) {
+      throw new Error(`No supported tech stack detected in ${projectRoot}`);
+    }
+    const techStack = detectionResult.detectedStacks[0];
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      projectRoot,
+      techStack,
+      findings: [],
+      summary: { critical: 0, high: 0, medium: 0, low: 0, total: 0 },
+      scannedFiles: 0,
+      scanDurationMs: 0,
+      errors: ["Quick scan without LLM context is not fully supported. Use run(ctx, options) for full scan."]
+    };
+  }
+};
+var defaultOrchestrator = new SecurityScannerOrchestrator();
+function createSecuritySlashCommand() {
+  return {
+    name: "security",
+    description: "Security scanning commands: scan, audit, report",
+    argsHint: "[scan|audit|report] [options]",
+    help: `
+# /security \u2014 Security Scanner
+
+Security scanning with automatic tech stack detection.
+
+## Commands
+
+### /security scan [options]
+Run a full security scan on the current project.
+Options:
+  --depth quick|standard|deep  Scan depth (default: standard)
+  --format markdown|json|html   Report format (default: markdown)
+
+### /security audit
+Run dependency audit + security scan.
+Checks for known vulnerabilities in dependencies.
+
+### /security report [id]
+Show a previous security report.
+  /security report          - List available reports
+  /security report <id>     - Show specific report
+
+## Examples
+
+/security scan
+/security scan --depth deep --format html
+/security audit
+/security report
+/security report 2025-01-15
+`,
+    async run(args, ctx) {
+      const parts = args.trim().split(/\s+/);
+      const subcommand = parts[0] || "";
+      const subArgs = parts.slice(1).join(" ");
+      switch (subcommand) {
+        case "scan":
+          return handleScan(subArgs, ctx);
+        case "audit":
+          return handleAudit(ctx);
+        case "report":
+          return handleReport(subArgs);
+        default:
+          return { message: getHelpMessage() };
+      }
+    }
+  };
+}
+async function handleScan(args, ctx) {
+  const options = parseArgs(args);
+  const projectRoot = ctx.projectRoot || ctx.cwd || process.cwd();
+  try {
+    const result = await defaultOrchestrator.run(ctx, {
+      projectRoot,
+      scanOptions: {
+        depth: options.depth || "standard",
+        includeSecrets: true,
+        includeInjection: true,
+        includeConfig: true
+      },
+      reportOptions: {
+        format: options.format || "markdown"
+      }
+    });
+    const summary = result.scanResult.summary;
+    const status = summary.total === 0 ? "\u2705 No issues found" : `\u26A0\uFE0F Found ${summary.total} issues`;
+    const reportContent = result.synthesizedReport || `# Security Scan Complete
+
+**Project:** ${projectRoot}
+**Tech Stack:** ${result.detectionResult.detectedStacks[0]?.stack || "unknown"}
+**Scanned Files:** ${result.scanResult.scannedFiles}
+**Duration:** ${result.scanResult.scanDurationMs}ms
+
+## Summary
+
+| Severity | Count |
+|----------|-------|
+| \u{1F534} Critical | ${summary.critical} |
+| \u{1F7E0} High | ${summary.high} |
+| \u{1F7E1} Medium | ${summary.medium} |
+| \u{1F7E2} Low | ${summary.low} |
+
+**Status:** ${status}
+
+**Report:** ${result.reportPath}
+`;
+    return {
+      message: reportContent,
+      metadata: {
+        scanResult: result.scanResult,
+        reportPath: result.reportPath,
+        techStack: result.detectionResult.detectedStacks[0]
+      }
+    };
+  } catch (error) {
+    return { message: `\u274C Scan failed: ${error}` };
+  }
+}
+async function handleAudit(ctx) {
+  const projectRoot = ctx.projectRoot || ctx.cwd || process.cwd();
+  try {
+    const result = await defaultOrchestrator.run(ctx, {
+      projectRoot,
+      reportOptions: { format: "markdown" }
+    });
+    const depIssues = result.scanResult.summary.critical + result.scanResult.summary.high;
+    const reportContent = result.synthesizedReport || `
+# Security Audit Complete
+
+**Project:** ${projectRoot}
+**Tech Stack:** ${result.detectionResult.detectedStacks[0]?.stack || "unknown"}
+
+## Dependency Health
+
+| Status | Count |
+|--------|-------|
+| Critical Issues | ${result.scanResult.summary.critical} |
+| High Priority | ${result.scanResult.summary.high} |
+| Medium Priority | ${result.scanResult.summary.medium} |
+| Low Priority | ${result.scanResult.summary.low} |
+
+${depIssues === 0 ? "\u2705 No known vulnerabilities detected" : `\u26A0\uFE0F ${depIssues} vulnerabilities need attention`}
+
+**Full Report:** ${result.reportPath}
+`;
+    return {
+      message: reportContent,
+      metadata: {
+        scanResult: result.scanResult,
+        reportPath: result.reportPath
+      }
+    };
+  } catch (error) {
+    return { message: `\u274C Audit failed: ${error}` };
+  }
+}
+async function handleReport(reportId) {
+  const reportsDir = "security-reports";
+  try {
+    const files = await readdir(reportsDir);
+    const reports = files.filter((f) => f.startsWith("security-report-") && (f.endsWith(".md") || f.endsWith(".json"))).sort().reverse();
+    if (!reportId) {
+      if (reports.length === 0) {
+        return { message: "\u{1F4ED} No security reports found. Run `/security scan` first." };
+      }
+      const list = reports.map((r, i) => {
+        const date = r.replace("security-report-", "").replace(/\.(md|json)$/, "");
+        return `  ${i + 1}. ${date}`;
+      }).join("\n");
+      return { message: `# Available Security Reports
+
+${list}
+
+Use \`/security report <number>\` to view a specific report.` };
+    }
+    const index = parseInt(reportId, 10) - 1;
+    if (!isNaN(index) && reports[index]) {
+      const { readFile: readFile28 } = await import('fs/promises');
+      const content = await readFile28(join(reportsDir, reports[index]), "utf-8");
+      return { message: `# Security Report
+
+${content}` };
+    }
+    const match = reports.find((r) => r.includes(reportId));
+    if (match) {
+      const { readFile: readFile28 } = await import('fs/promises');
+      const content = await readFile28(join(reportsDir, match), "utf-8");
+      return { message: `# Security Report
+
+${content}` };
+    }
+    return { message: `\u274C Report "${reportId}" not found. Use \`/security report\` to see available reports.` };
+  } catch (error) {
+    return { message: "\u{1F4ED} No security reports found. Run `/security scan` first." };
+  }
+}
+function parseArgs(args) {
+  const result = {};
+  const parts = args.split(/\s+/);
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (!part || !part.startsWith("--")) continue;
+    const key = part.slice(2);
+    const next = parts[i + 1];
+    if (next && !next.startsWith("--")) {
+      result[key] = next;
+      i++;
+    } else {
+      result[key] = "true";
+    }
+  }
+  return result;
+}
+function getHelpMessage() {
+  return `
+# /security \u2014 Security Scanner
+
+**Available Commands:**
+
+1. **/security scan** \u2014 Run full security scan
+   Options: --depth quick|standard|deep, --format markdown|json|html
+
+2. **/security audit** \u2014 Run dependency audit + security scan
+
+3. **/security report** \u2014 List or view security reports
+
+**Examples:**
+\`\`\`
+/security scan
+/security scan --depth deep --format html
+/security audit
+/security report
+\`\`\`
+`;
+}
+var securitySlashCommand = createSecuritySlashCommand();
 
 // src/extension/registry.ts
 var ExtensionRegistry = class {
@@ -14619,8 +16997,8 @@ ${mem}`);
   }
   async dirExists(p) {
     try {
-      const stat6 = await fsp2.stat(p);
-      return stat6.isDirectory();
+      const stat8 = await fsp2.stat(p);
+      return stat8.isDirectory();
     } catch {
       return false;
     }
@@ -15371,6 +17749,6 @@ function wrapApiForCapabilityCheck(plugin, api, log, enforce = false) {
   });
 }
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorBudgetError, DirectorStateCheckpoint, DoneConditionChecker, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SessionError, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMessage, createToolOutputSerializer, decryptConfigSecrets, detectNewlineStyle, downloadGitHubTarball, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatPlan, formatTodosList, getContextWindowMode, getTemplate, githubServer, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listTemplates, loadDirectorState, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorBudgetError, DirectorStateCheckpoint, DoneConditionChecker, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetUsageAggregator, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, asBlocks, asText, atomicWrite, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildChildEnv, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, downloadGitHubTarball, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatPlan, formatPlanTemplates, formatTodosList, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseSkillRef, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, savePlan, saveTodosCheckpoint, securitySlashCommand, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map