@wrongstack/core 0.107.2 → 0.119.1

package/dist/execution/index.d.ts

@@ -1,24 +1,23 @@
-export { C as CompactorOptions, D as DefaultErrorHandler, a as DefaultRetryPolicy, E as EternalAutonomyEngine, b as EternalAutonomyOptions, c as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, d as ParallelEternalEngine, e as ParallelEternalOptions, f as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-CUtmM_0V.js';
-export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as buildGoalPreamble, m as makeAutonomyPromptContributor } from '../goal-preamble-CI8lxeY1.js';
-import { P as Provider } from '../context-CNRYfhUv.js';
-import { B as BrainDecision, a as BrainDecisionRequest, b as BrainArbiter } from '../brain-Dfv4Y82E.js';
-import '../retry-policy-BcmuT_V0.js';
-import '../compactor-DXLxLcmU.js';
-import '../models-registry-B6_KfS65.js';
-import '../index-DIKEcfgC.js';
+export { C as CompactorOptions, D as DefaultErrorHandler, a as DefaultRetryPolicy, E as EternalAutonomyEngine, b as EternalAutonomyOptions, c as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, d as ParallelEternalEngine, e as ParallelEternalOptions, f as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-uxVm4y4V.js';
+export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as buildGoalPreamble, m as makeAutonomyPromptContributor } from '../goal-preamble-COpt55W8.js';
+import { P as Provider } from '../context-hvXINa6a.js';
+import { B as BrainDecision, a as BrainDecisionRequest, b as BrainArbiter } from '../brain-NZZqL8sn.js';
+import '../retry-policy-B4Q-FZgE.js';
+import '../compactor-C3stu664.js';
+import '../config-DZV9VK9n.js';
+import '../index-4VVHuTZF.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-BqiA_UMr.js';
-import '../config-BSU-6vah.js';
+import '../pipeline-CqF7uju2.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-BDv7z0mk.js';
-import '../agent-subagent-runner-DukQLUcS.js';
-import '../goal-store-ht0VmR1A.js';
-import '../multi-agent-coordinator-51LvnXkD.js';
+import '../permission-DhLrgA30.js';
+import '../agent-subagent-runner-DXWImnNV.js';
+import '../goal-store-CV9Yz2X_.js';
+import '../multi-agent-coordinator-CmDmUgq2.js';
 import 'node:events';
 import '../skill-Bj6Ezqb8.js';
-import '../wstack-paths-_lqjzErq.js';
-import '../selector-C7wcdqMA.js';
-import '../session-event-bridge-BpJ5trO9.js';
+import '../wstack-paths-DD50Omgn.js';
+import '../selector-BakeMnWR.js';
+import '../session-event-bridge-DE5Oekwx.js';
 
 /**
  * AutonomyBrain — a self-driving decision layer for autonomous workflows.

package/dist/execution/index.js

@@ -1,8 +1,8 @@
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import * as fs from 'fs/promises';
-import * as path from 'path';
-import { randomUUID, createHash, randomBytes } from 'crypto';
+import { randomUUID, randomBytes, createHash } from 'crypto';
+import * as path2 from 'path';
 import * as os from 'os';
 import { EventEmitter } from 'events';
 
@@ -2064,9 +2064,9 @@ var AutonomousRunner = class {
   }
 };
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path.dirname(targetPath);
+  const dir = path2.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
-  const tmp = path.join(dir, `.${path.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -2124,27 +2124,82 @@ async function renameWithRetry(from, to) {
   }
   throw lastErr;
 }
+function projectHash(absRoot) {
+  return createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 12);
+}
+function projectSlug(absRoot) {
+  const base = slugify(path2.basename(absRoot));
+  const hash = createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
+function resolveWstackPaths(opts) {
+  const home = opts.userHome ?? os.homedir();
+  const globalRoot = opts.globalRoot ?? path2.join(home, ".wrongstack");
+  const hash = projectHash(opts.projectRoot);
+  const slug = projectSlug(opts.projectRoot);
+  const projectDir = path2.join(globalRoot, "projects", slug);
+  return {
+    globalRoot,
+    configDir: globalRoot,
+    globalConfig: path2.join(globalRoot, "config.json"),
+    secretsKey: path2.join(globalRoot, ".key"),
+    globalMemory: path2.join(globalRoot, "memory.md"),
+    globalSkills: path2.join(globalRoot, "skills"),
+    globalPrompts: path2.join(globalRoot, "prompts"),
+    cacheDir: path2.join(globalRoot, "cache"),
+    modelsCache: path2.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path2.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path2.join(globalRoot, "history"),
+    logFile: path2.join(globalRoot, "logs", "wrongstack.log"),
+    projectDir,
+    projectCodebaseIndex: path2.join(projectDir, "codebase-index"),
+    projectMemory: path2.join(projectDir, "memory.md"),
+    projectSessions: path2.join(projectDir, "sessions"),
+    projectTrust: path2.join(projectDir, "trust.json"),
+    projectMeta: path2.join(projectDir, "meta.json"),
+    projectLocalConfig: path2.join(projectDir, "config.local.json"),
+    inProjectConfig: path2.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path2.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path2.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectWorktrees: path2.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectHash: hash,
+    projectSlug: slug,
+    projectGoal: path2.join(projectDir, "goal.json"),
+    projectSpecs: path2.join(projectDir, "specs"),
+    projectTaskGraphs: path2.join(projectDir, "task-graphs"),
+    projectSddSession: path2.join(projectDir, "sdd-session.json"),
+    projectPlan: path2.join(projectDir, "plan.json"),
+    projectAutophase: path2.join(projectDir, "autophase"),
+    syncConfig: path2.join(globalRoot, "sync.json")
+  };
+}
 
 // src/storage/goal-store.ts
 var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
-  const hash = createHash("sha256").update(path.resolve(projectRoot)).digest("hex").slice(0, 12);
-  return path.join(os.homedir(), ".wrongstack", "projects", hash, "goal.json");
+  return resolveWstackPaths({ projectRoot }).projectGoal;
 }
 async function loadGoal(filePath) {
   let raw;
   try {
     raw = await fs.readFile(filePath, "utf8");
-  } catch {
-    return null;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return null;
+    throw err;
   }
   try {
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
+      console.warn(`[goal-store] Corrupt goal.json at ${filePath} \u2014 invalid schema. Consider deleting it and re-creating.`);
       return null;
     }
     return parsed;
   } catch {
+    console.warn(`[goal-store] Corrupt goal.json at ${filePath} \u2014 JSON parse failed. Consider deleting it and re-creating.`);
     return null;
   }
 }
@@ -2198,7 +2253,7 @@ function computeTrend(history) {
   const recent = history.slice(-5);
   const deltas = [];
   for (let i = 1; i < recent.length; i++) {
-    deltas.push(recent[i].progress - recent[i - 1].progress);
+    deltas.push((recent[i]?.progress ?? 0) - (recent[i - 1]?.progress ?? 0));
   }
   if (deltas.length < 2) return void 0;
   const avgDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
@@ -2957,8 +3012,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned);
     }
     try {
-      const { unlink: unlink2 } = await import('fs/promises');
-      await unlink2(this.goalPath);
+      const { unlink: unlink3 } = await import('fs/promises');
+      await unlink3(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -3959,6 +4014,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"
+      ]
+    }
   }
 ];
 
@@ -4498,6 +4600,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"
+      ]
+    }
   }
 ];
 
@@ -7505,6 +7758,7 @@ var DefaultRetryPolicy = class {
     if (err instanceof ProviderError) {
       if (err.status === 429) return 5;
       if (err.status === 529) return 3;
+      if (err.status === 599) return 5;
       if (err.status >= 500) return 3;
       return 0;
     }
@@ -7624,7 +7878,7 @@ var DefaultSkillLoader = class {
         const entries = await fs.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
           if (!e.isDirectory()) continue;
-          const skillFile = path.join(dir, e.name, "SKILL.md");
+          const skillFile = path2.join(dir, e.name, "SKILL.md");
           try {
             const raw = await fs.readFile(skillFile, "utf8");
             const meta = parseFrontmatter(raw);