@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-ZT7JNIGX.js

@@ -0,0 +1,152 @@
+import {
+  ensureProjectGitignore
+} from "./chunk-HI3JGZR2.js";
+
+// src/utils/config-backup.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+function configHistoryDir(globalRoot) {
+  return path.join(globalRoot, "config-history");
+}
+function configSlug(absolutePath, globalRoot) {
+  const rel = path.relative(globalRoot, absolutePath);
+  const normalized = rel.replace(/\\/g, "/").replace(/\.json$/i, "");
+  return normalized.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "config";
+}
+async function backupConfigFile(filePath, paths) {
+  let currentContent;
+  try {
+    currentContent = await fs.readFile(filePath, "utf8");
+    if (!currentContent.trim()) return;
+  } catch {
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[:.]/g, "-").replace(/Z$/, "");
+  const slug = configSlug(filePath, paths.globalRoot);
+  const backupDir = configHistoryDir(paths.globalRoot);
+  const backupFile = path.join(backupDir, `${slug}-${ts}.json`);
+  try {
+    await fs.mkdir(backupDir, { recursive: true });
+    await fs.writeFile(backupFile, currentContent, { mode: 384, encoding: "utf8" });
+  } catch {
+  }
+}
+
+// src/utils/project-state-guard.ts
+import * as fs2 from "node:fs";
+import * as fsp from "node:fs/promises";
+import * as path2 from "node:path";
+var PROJECT_STATE_DIRECTORY = ".wrongstack";
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+var REPAIR_DEBOUNCE_MS = 25;
+var ACTIVE_GUARD_KEY = /* @__PURE__ */ Symbol.for("wrongstack.activeProjectStateGuard");
+var globalScope = globalThis;
+globalScope[ACTIVE_GUARD_KEY] ??= {};
+var activeGuard = globalScope[ACTIVE_GUARD_KEY];
+function normalizedRoot(root) {
+  const resolved = path2.resolve(root);
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function concernsProjectState(filename) {
+  if (filename === null) return true;
+  const firstSegment = String(filename).replaceAll("\\", "/").split("/")[0];
+  return firstSegment?.toLowerCase() === PROJECT_STATE_DIRECTORY;
+}
+async function startProjectStateGuard(projectRoot, options = {}) {
+  const root = path2.resolve(projectRoot);
+  const directory = path2.join(root, PROJECT_STATE_DIRECTORY);
+  const pollIntervalMs = Math.max(25, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+  let closed = false;
+  let repairPending = false;
+  let repairInFlight;
+  let repairTimer;
+  const ensureDirectory = async () => {
+    await fsp.mkdir(directory, { recursive: true });
+  };
+  const ensureInvariant = async () => {
+    await ensureDirectory();
+    try {
+      await ensureProjectGitignore(root);
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const scheduleRepair = () => {
+    if (closed) return;
+    repairPending = true;
+    if (repairInFlight || repairTimer) return;
+    repairTimer = setTimeout(() => {
+      repairTimer = void 0;
+      repairInFlight = (async () => {
+        while (!closed && repairPending) {
+          repairPending = false;
+          try {
+            const rootState = await fsp.stat(root).catch(() => void 0);
+            if (!rootState?.isDirectory()) return;
+            await ensureInvariant();
+          } catch (error) {
+            options.onError?.(error);
+          }
+        }
+      })().finally(() => {
+        repairInFlight = void 0;
+        if (repairPending && !closed) scheduleRepair();
+      });
+    }, REPAIR_DEBOUNCE_MS);
+    repairTimer.unref?.();
+  };
+  await ensureDirectory();
+  await ensureProjectGitignore(root).catch((error) => options.onError?.(error));
+  let watcher;
+  try {
+    watcher = fs2.watch(root, { persistent: false }, (_eventType, filename) => {
+      if (concernsProjectState(filename) || String(filename).toLowerCase() === ".gitignore") {
+        scheduleRepair();
+      }
+    });
+    watcher.on("error", (error) => {
+      options.onError?.(error);
+      watcher = void 0;
+      scheduleRepair();
+    });
+  } catch (error) {
+    options.onError?.(error);
+  }
+  const poll = setInterval(scheduleRepair, pollIntervalMs);
+  poll.unref?.();
+  return {
+    directory,
+    close() {
+      if (closed) return;
+      closed = true;
+      clearInterval(poll);
+      if (repairTimer) clearTimeout(repairTimer);
+      repairTimer = void 0;
+      try {
+        watcher?.close();
+      } catch {
+      }
+      watcher = void 0;
+    }
+  };
+}
+async function activateProjectStateGuard(projectRoot, options = {}) {
+  const root = normalizedRoot(projectRoot);
+  if (activeGuard.root === root && activeGuard.guard) return activeGuard.guard;
+  const next = await startProjectStateGuard(projectRoot, options);
+  const previous = activeGuard.guard;
+  activeGuard.root = root;
+  activeGuard.guard = next;
+  previous?.close();
+  return next;
+}
+
+export {
+  configHistoryDir,
+  configSlug,
+  backupConfigFile,
+  startProjectStateGuard,
+  activateProjectStateGuard
+};
+//# sourceMappingURL=chunk-ZT7JNIGX.js.map

package/dist/coordination/agent-monitor.d.ts

@@ -104,8 +104,16 @@ export declare class AgentMonitorService {
      *
      * Entries already in the ring win: a live subagent's in-memory segment is
      * newer than its JSONL, which is only written when a segment closes.
+     *
+     * `only` restricts BOTH the disk scan and the returned set to a known list of
+     * subagent ids. This is how a session gets ITS OWN subagents back: the
+     * transcripts directory is shared by every session of the project, so the
+     * unfiltered form hands each of four open tabs the union of all four tabs'
+     * workers. The caller derives the list from the session's own journal
+     * (`deriveSessionAgents`), which is the only record that says which agents
+     * belong to which session.
      */
-    loadSessionsFromDisk(): Promise<AgentVirtualSession[]>;
+    loadSessionsFromDisk(only?: readonly string[]): Promise<AgentVirtualSession[]>;
     private _readTranscriptFile;
     /** Get a specific agent's virtual session, or undefined. */
     getSession(subagentId: string): AgentVirtualSession | undefined;

package/dist/coordination/agent-subagent-runner.d.ts

@@ -36,7 +36,7 @@ export interface AgentFactoryResult {
      * thrown here are swallowed so a flaky cleanup can't mask the task's
      * real result.
      */
-    dispose?: ((() => Promise<void> | void)) | undefined;
+    dispose?: (() => Promise<void> | void) | undefined;
 }
 export interface AgentRunnerOptions {
     factory: AgentFactory;

package/dist/coordination/agents/agent-prompts.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Number of live prompt-cache entries.
+ *
+ * Exposed so the "one entry per role, regardless of how many times the overlay
+ * is rewritten" bound above is testable. The old fingerprint-in-key scheme grew
+ * this without limit and nothing could observe it.
+ */
+export declare function agentPromptCacheSize(): number;
 export declare function agentPrompt(id: string): string;
 //# sourceMappingURL=agent-prompts.d.ts.map

package/dist/coordination/agents/index.d.ts

@@ -23,13 +23,33 @@ import { WAVE3_AGENTS } from './phase8-wave3-products.js';
 import { META_AGENTS } from './phase9-meta.js';
 import { WAVE4_AGENTS } from './phase9-wave4-platform-meta.js';
 import { ROLE_SKILL_SETS, SHADOW_AGENT_SKILLS } from './role-skills.js';
-import type { AgentDefinition } from './types.js';
+import type { AgentCapability, AgentDefinition } from './types.js';
 export * from './capability-manifest.js';
 export * from './phase3-wave1-platform.js';
 export * from './phase3-wave2-meta.js';
 export * from './phase8-wave3-products.js';
 export * from './phase9-wave4-platform-meta.js';
+export * from './project-agent-auto-optimize.js';
+export * from './project-agent-capture-window.js';
+export * from './project-agent-capture.js';
+export * from './project-agent-config-io.js';
+export * from './project-agent-config-validation.js';
+export * from './project-agent-consolidation.js';
+export * from './project-agent-directive-outcome.js';
+export * from './project-agent-files.js';
+export * from './project-agent-identity-types.js';
 export * from './project-agent-identity.js';
+export * from './project-agent-knowledge-manifests.js';
+export * from './project-agent-learning-entries.js';
+export * from './project-agent-learning-normalize.js';
+export * from './project-agent-learning-policy.js';
+export * from './project-agent-learning-structured.js';
+export * from './project-agent-optimizer.js';
+export * from './project-agent-paths.js';
+export * from './project-agent-profile.js';
+export * from './project-agent-quarantine.js';
+export * from './project-agent-roster.js';
+export * from './project-agent-skill-layer.js';
 export * from './role-skills.js';
 export * from './types.js';
 export { BUILD_AGENTS, DELIVERY_AGENTS, DISCOVERY_AGENTS, DOMAIN_AGENTS, KNOWLEDGE_AGENTS, META_AGENTS, PLANNING_AGENTS, REVIEW_AGENTS, VERIFY_AGENTS, WAVE1_AGENTS, WAVE2_AGENTS, WAVE3_AGENTS, WAVE4_AGENTS, };
@@ -53,5 +73,17 @@ export declare const AGENTS_BY_PHASE: {
 export declare const AGENT_CATALOG: Record<string, AgentDefinition>;
 /** Role lookup helper. Returns undefined for unknown roles. */
 export declare function getAgentDefinition(role: string): AgentDefinition | undefined;
+/**
+ * Role → dispatcher rationale, for every role that declares one.
+ *
+ * Derived from the catalog rather than hand-listed. There used to be four
+ * hand-maintained `WAVE*_ROLE_METAS` maps beside the agent arrays; nothing
+ * read them, and `WAVE2_ROLE_METAS` had drifted to carry six roles that live
+ * in `WAVE4_AGENTS` — a duplicate set no consumer would ever have noticed
+ * because the map itself was dead. Deriving from `AGENT_CATALOG` makes that
+ * class of drift impossible: a role is listed here exactly when its own
+ * `capability.rationale` is set.
+ */
+export declare const ROLE_DISPATCH_RATIONALE: Record<string, NonNullable<AgentCapability['rationale']>>;
 export { ROLE_SKILL_SETS, SHADOW_AGENT_SKILLS };
 //# sourceMappingURL=index.d.ts.map