@wrongstack/core 0.107.2 → 0.119.1

package/dist/{plan-templates-BdDxl9cI.d.ts → plan-templates-DoKhzenv.d.ts}

@@ -1,9 +1,9 @@
-import { E as EventBus, M as MemoryScope, k as MemoryEntry, l as MemoryStore, m as MemoryRelevanceContext, S as ScoredEntry } from './brain-Dfv4Y82E.js';
-import { S as SecretScrubber } from './permission-BDv7z0mk.js';
-import { i as SessionStore, h as SessionMetadata, a as SessionWriter, p as ResumedSession, q as SessionData, r as SessionSummary, g as ContentBlock, S as SessionEvent, s as TodoItem, t as ConversationState } from './context-CNRYfhUv.js';
-import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-DDz1Ek4V.js';
-import { W as WstackPaths } from './wstack-paths-_lqjzErq.js';
-import { e as ConfigStore, d as Config, f as ConfigLoader, g as SyncConfig } from './config-BSU-6vah.js';
+import { E as EventBus, M as MemoryScope, k as MemoryEntry, l as MemoryStore, m as MemoryRelevanceContext, S as ScoredEntry } from './brain-NZZqL8sn.js';
+import { S as SecretScrubber } from './permission-DhLrgA30.js';
+import { i as SessionStore, h as SessionMetadata, a as SessionWriter, p as ResumedSession, q as SessionData, r as SessionSummary, g as ContentBlock, S as SessionEvent, s as TodoItem, t as ConversationState } from './context-hvXINa6a.js';
+import { A as AttachmentStore, a as AddAttachmentInput, b as AttachmentRef, c as Attachment } from './session-reader-DFC81-4p.js';
+import { W as WstackPaths } from './wstack-paths-DD50Omgn.js';
+import { i as ConfigStore, h as Config, j as ConfigLoader, k as SyncConfig } from './config-DZV9VK9n.js';
 import { S as SecretVault } from './secret-vault-DoISxaKO.js';
 
 interface SessionStoreOptions {

package/dist/{provider-runner-BUunikwY.d.ts → provider-runner-BPlI5sPZ.d.ts}

@@ -1,8 +1,8 @@
-import { E as EventBus } from './brain-Dfv4Y82E.js';
+import { E as EventBus } from './brain-NZZqL8sn.js';
 import { L as Logger } from './logger-B63L5bTg.js';
 import { T as Tracer } from './observability-D-HZN_mF.js';
-import { P as Provider, R as Request, C as Context, b as Response } from './context-CNRYfhUv.js';
-import { R as RetryPolicy } from './retry-policy-BcmuT_V0.js';
+import { P as Provider, R as Request, C as Context, b as Response } from './context-hvXINa6a.js';
+import { R as RetryPolicy } from './retry-policy-B4Q-FZgE.js';
 
 /**
  * Options passed to a ProviderRunner when calling the provider.

package/dist/{retry-policy-BcmuT_V0.d.ts → retry-policy-B4Q-FZgE.d.ts}

@@ -1,4 +1,4 @@
-import { C as Context, b as Response, e as ProviderError } from './context-CNRYfhUv.js';
+import { C as Context, b as Response, e as ProviderError } from './context-hvXINa6a.js';
 
 type RecoveryDecision = {
     /**

package/dist/sdd/index.d.ts

@@ -1,16 +1,15 @@
 import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../spec-TBi3Jr6T.js';
 import { d as TaskGraph, e as TaskNode, i as TaskFilter, j as TaskSort, c as TaskProgress, T as TaskType, a as TaskPriority } from '../task-graph-u1q9Jkyk.js';
-import { E as EventBus } from '../brain-Dfv4Y82E.js';
-import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-DukQLUcS.js';
-import '../context-CNRYfhUv.js';
-import '../index-DIKEcfgC.js';
+import { E as EventBus } from '../brain-NZZqL8sn.js';
+import { D as DoneCondition, g as Agent, h as AgentFactory, f as TaskResult } from '../agent-subagent-runner-DXWImnNV.js';
+import '../context-hvXINa6a.js';
+import '../index-4VVHuTZF.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-BqiA_UMr.js';
-import '../config-BSU-6vah.js';
-import '../models-registry-B6_KfS65.js';
+import '../pipeline-CqF7uju2.js';
+import '../config-DZV9VK9n.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-BDv7z0mk.js';
-import '../retry-policy-BcmuT_V0.js';
+import '../permission-DhLrgA30.js';
+import '../retry-policy-B4Q-FZgE.js';
 
 declare class SpecParser {
     parse(content: string): Specification;

package/dist/sdd/index.js

@@ -3721,6 +3721,53 @@ Working rules:
         "flaws"
       ]
     }
+  },
+  {
+    config: {
+      id: "refactor-planner",
+      name: "Refactor Planner",
+      role: "refactor-planner",
+      tools: [...PLAN_TOOLS, "diff"],
+      prompt: `You are the Refactor Planner agent. Your job is to analyze code
+structure and produce a concrete, phased refactoring plan with risk
+assessment, dependency ordering, and rollback strategy.
+
+Scope:
+- Map module-level dependencies (import graph)
+- Identify coupling hotspots (high fan-in/out modules)
+- Assess refactoring risk by complexity and test coverage
+- Generate phased plans with checkpoint milestones
+- Produce diff-friendly task lists (one task = one concern)
+
+Input format you accept:
+{ "task": "plan | assess | roadmap", "target": "src/core", "constraint": "no-breaking-changes | minimal-downtime | full-rewrite", "focus": "architecture | performance | maintainability" }
+
+Output: Markdown refactor plan with phases (Low Risk / Medium Risk / High Risk),
+dependency graph, rollback strategy, and exit criteria.
+
+Working rules:
+- Always include rollback strategy \u2014 every refactor can fail
+- Merge tasks that take <1h into a single phase
+- Respect team constraints (reviewer availability, parallelization)
+- Never plan without analyzing the actual code first`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "planning",
+      summary: "Refactoring planner: analyzes code structure, maps dependencies, produces risk-scored phased plans with rollback strategy.",
+      keywords: [
+        "refactor",
+        "refactoring",
+        "restructure",
+        "debt",
+        "technical debt",
+        "clean up",
+        "modularize",
+        "decouple",
+        "dependency graph",
+        "code structure"
+      ]
+    }
   }
 ];
 
@@ -4260,6 +4307,157 @@ Working rules:
         "robustness"
       ]
     }
+  },
+  {
+    config: {
+      id: "security-scanner",
+      name: "Security Scanner",
+      role: "security-scanner",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Security Scanner agent. Your job is to scan code,
+configs, and dependencies for security issues from hardcoded secrets to
+supply chain risks.
+
+Scope:
+- Detect hardcoded secrets: API keys, tokens, passwords, private keys
+- Find injection vectors: eval, innerHTML, SQL concat, shell injection
+- Identify insecure patterns: weak crypto, hardcoded IVs, disabled TLS
+- Scan dependencies for known CVEs (via npm/pnpm audit)
+- Flag supply chain risks: postinstall hooks, unverified scripts
+
+Input format you accept:
+{ "task": "scan | audit | secrets | dependencies", "paths": ["src", "config"], "depth": "quick | normal | deep" }
+
+Output: Markdown security report with severity-ranked findings, injection
+vectors, dependency issues, and a remediation checklist.
+
+Working rules:
+- Never scan node_modules \u2014 use npm audit instead
+- Always provide remediation steps, not just findings
+- Verify regex-based secrets before flagging (false positive risk)
+- When in doubt, flag as medium rather than ignoring potential issues`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Security scanner: detects hardcoded secrets, injection vectors, insecure patterns, and supply-chain risks with remediation.",
+      keywords: [
+        "security",
+        "scan",
+        "vulnerability",
+        "secret",
+        "api key",
+        "hardcoded",
+        "injection",
+        "cve",
+        "audit dependencies",
+        "supply chain",
+        "xss",
+        "sqli",
+        "shell injection",
+        "sensitive data",
+        "credential"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "bug-hunter",
+      name: "Bug Hunter",
+      role: "bug-hunter",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Bug Hunter agent. Your job is to systematically scan
+source code for bugs, anti-patterns, and code smells using pattern matching
+and heuristics. Output a prioritized hit list with file:line references.
+
+Scope:
+- Detect common bug patterns (uncaught errors, resource leaks, race conditions)
+- Identify anti-patterns (callback hell, God objects, circular deps)
+- Find TypeScript-specific issues (unsafe any, missing null checks, branded types)
+- Flag security-sensitive constructs (eval, innerHTML, hardcoded secrets)
+- Rank findings: critical > high > medium > low
+
+Input format you accept:
+{ "task": "scan | hunt | check", "paths": ["src/**/*.ts"], "focus": "bugs | patterns | security | all", "severityThreshold": "medium" }
+
+Output: Markdown bug hunt report with critically/high/medium/low sections.
+Each entry: **[TYPE]** \`file:line\` \u2014 description + suggested fix
+
+Working rules:
+- Never scan node_modules \u2014 it's noise
+- Always include file:line for every finding
+- If >30% of findings are false positives, note the confidence level
+- Ask director for clarification if paths are ambiguous`
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Bug hunter: scans source code for bugs, anti-patterns, and code smells, producing a file:line-ranked hit list with fixes.",
+      keywords: [
+        "bug",
+        "hunt",
+        "scan",
+        "code smell",
+        "anti-pattern",
+        "race condition",
+        "memory leak",
+        "null deref",
+        "type safety",
+        "unhandled error",
+        "find bugs",
+        "audit code",
+        "code quality"
+      ]
+    }
+  },
+  {
+    config: {
+      id: "audit-log",
+      name: "Audit Log",
+      role: "audit-log",
+      tools: [...TOOLS.inspect],
+      prompt: `You are the Audit Log agent. Your job is to analyze structured JSONL
+session logs and produce actionable markdown reports.
+
+Scope:
+- Parse session logs (iteration counts, tool calls, errors, usage)
+- Detect repeated failure patterns across multiple runs
+- Identify tool usage anomalies (over-use, failures, unexpected chains)
+- Track token consumption trends
+- Generate structured audit reports with severity ratings
+
+Input format you accept:
+{ "task": "analyze | report | trends", "sessionPath": "<path>", "focus": "errors | tools | usage | all" }
+
+Output: Markdown audit report with Summary, Top Errors, Tool Usage table,
+Anomalies, and Cost Trend sections.
+
+Working rules:
+- Never fabricate numbers \u2014 read the actual logs first
+- Always include file:line references for errors
+- If sessionPath is missing, ask the director to provide it
+- Report confidence level: high (>90% accuracy), medium, low`
+    },
+    budget: MEDIUM_BUDGET,
+    capability: {
+      phase: "verify",
+      summary: "Audit log analyzer: parses session JSONL, detects failure patterns, tool anomalies, and cost trends with structured reports.",
+      keywords: [
+        "audit",
+        "log",
+        "logs",
+        "session",
+        "trace",
+        "analyze logs",
+        "error patterns",
+        "cost analysis",
+        "tool usage",
+        "token usage",
+        "post-mortem",
+        "trend",
+        "anomaly"
+      ]
+    }
   }
 ];