@wrongstack/core 0.299.0 → 0.301.0

package/dist/chronicle/project-server.js

@@ -2,7 +2,7 @@
 
 // src/chronicle/project-server.ts
 import { randomBytes } from "node:crypto";
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as fsp4 from "node:fs/promises";
 import * as net from "node:net";
 import * as path15 from "node:path";
@@ -3696,6 +3696,7 @@ function ensureChronicleProjectServerSocketDirectory(endpoint2) {
 
 // src/chronicle/sqlite-journal.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
+import * as fs9 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import * as path14 from "node:path";
 
@@ -3941,6 +3942,25 @@ var CHRONICLE_SQLITE_FILE = "chronicle.sqlite";
 var LEGACY_JSONL_MIGRATION_KEY = "legacy-jsonl-v1";
 var LEGACY_JSONL_QUARANTINE_KEY = "legacy-jsonl-v1:quarantine";
 var SCHEMA_VERSION2 = 1;
+var SQLITE_FIXED_OVERHEAD_BYTES = 16 * 1024 * 1024;
+var MIN_SQLITE_PAGE_BUDGET_BYTES = 64 * 1024;
+var MAX_ROLLBACK_JOURNAL_RESERVE_BYTES = 64 * 1024 * 1024;
+var ChronicleStorageQuotaError = class extends Error {
+  currentBytes;
+  batchBytes;
+  maxBytes;
+  path;
+  constructor(details) {
+    super(
+      `Chronicle SQLite quota exceeded at ${details.path}: ${details.currentBytes} live bytes + ${details.batchBytes} batch bytes exceeds ${details.maxBytes}; lower chronicle retentionDays/maxEvents to shed data (run chronicle compact to return the freed pages to the filesystem)`
+    );
+    this.name = "ChronicleStorageQuotaError";
+    this.currentBytes = details.currentBytes;
+    this.batchBytes = details.batchBytes;
+    this.maxBytes = details.maxBytes;
+    this.path = details.path;
+  }
+};
 var Ctor2;
 function loadDatabaseSync2() {
   if (Ctor2) return Ctor2;
@@ -3963,6 +3983,14 @@ var ChronicleSqliteJournal = class {
   now;
   monotonicNow;
   idFactory;
+  retentionDays;
+  maxEvents;
+  maxBytes;
+  retentionCheckIntervalMs;
+  nextRetentionCheckAt = 0;
+  retainedEventCount = 0;
+  /** Resolved lazily by `pageSizeBytes()`; constant for an open database. */
+  cachedPageSize;
   /**
    * Cached chain head per day. Cleared wholesale on any write failure so the
    * next append rebuilds from the database rather than trusting a counter that
@@ -3984,10 +4012,36 @@ var ChronicleSqliteJournal = class {
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.monotonicNow = options.monotonicNow ?? (() => process.hrtime.bigint());
     this.idFactory = options.idFactory ?? (() => randomUUID3());
+    if (options.retentionDays !== void 0 && (!Number.isFinite(options.retentionDays) || options.retentionDays <= 0)) {
+      throw new RangeError("retentionDays must be a positive finite number");
+    }
+    if (options.retentionCheckIntervalMs !== void 0 && (!Number.isFinite(options.retentionCheckIntervalMs) || options.retentionCheckIntervalMs <= 0)) {
+      throw new RangeError("retentionCheckIntervalMs must be a positive finite number");
+    }
+    if (options.maxEvents !== void 0 && (!Number.isInteger(options.maxEvents) || options.maxEvents < 1)) {
+      throw new RangeError("maxEvents must be a positive integer");
+    }
+    if (options.maxBytes !== void 0 && (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1)) {
+      throw new RangeError("maxBytes must be a positive safe integer");
+    }
+    const minimumQuotaBytes = SQLITE_FIXED_OVERHEAD_BYTES + 2 * MIN_SQLITE_PAGE_BUDGET_BYTES;
+    if (options.maxBytes !== void 0 && options.maxBytes < minimumQuotaBytes) {
+      throw new RangeError(`maxBytes must be at least ${minimumQuotaBytes}`);
+    }
+    this.retentionDays = options.retentionDays;
+    this.maxEvents = options.maxEvents;
+    this.maxBytes = options.maxBytes;
+    this.retentionCheckIntervalMs = options.retentionCheckIntervalMs ?? 60 * 60 * 1e3;
     const Database = loadDatabaseSync2();
     this.db = new Database(this.dbPath);
-    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec(`PRAGMA journal_mode = ${this.maxBytes === void 0 ? "WAL" : "DELETE"}`);
     this.ensureSchema();
+    this.configureByteQuota();
+    if (this.maxEvents !== void 0) {
+      const row = this.db.prepare("SELECT COUNT(*) AS count FROM events").get();
+      this.retainedEventCount = row.count;
+      this.enforceEventLimitAtStartup();
+    }
   }
   close() {
     this.db.close();
@@ -4046,8 +4100,10 @@ var ChronicleSqliteJournal = class {
       events.push(event);
       previous = { sequence: event.sequence, hash: event.hash };
     }
+    let retainedCountAfterCommit = this.retainedEventCount;
     try {
       this.db.exec("BEGIN IMMEDIATE");
+      this.assertWithinByteQuota(events);
       const insert = this.db.prepare(
         `INSERT INTO events (
            day, sequence, event_id, hash, previous_hash, occurred_at, event_type, outcome,
@@ -4079,6 +4135,8 @@ var ChronicleSqliteJournal = class {
           JSON.stringify(event)
         );
       }
+      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction();
+      this.assertActualAllocationWithinQuota();
       this.db.exec("COMMIT");
     } catch (error) {
       try {
@@ -4088,11 +4146,13 @@ var ChronicleSqliteJournal = class {
       this.anchors.clear();
       this.counters.failedEvents += inputs.length;
       this.lastBatchDurationMs = performance.now() - started;
-      throw error;
+      throw this.normalizeQuotaError(error);
     }
     this.anchors.set(day, previous);
     this.counters.persistedEvents += events.length;
+    this.retainedEventCount = retainedCountAfterCommit;
     this.lastBatchDurationMs = performance.now() - started;
+    await this.enforceRetentionIfDue();
     return events;
   }
   async readAll() {
@@ -4153,6 +4213,145 @@ var ChronicleSqliteJournal = class {
     }
     return { ok: true, entries, lastSequence, lastHash };
   }
+  async enforceRetentionIfDue() {
+    if (this.retentionDays === void 0) return;
+    const now = this.now();
+    if (now.getTime() < this.nextRetentionCheckAt) return;
+    this.nextRetentionCheckAt = now.getTime() + this.retentionCheckIntervalMs;
+    try {
+      await this.purge({ retentionDays: this.retentionDays });
+    } catch {
+    }
+  }
+  configureByteQuota() {
+    if (this.maxBytes === void 0) {
+      this.db.exec("PRAGMA max_page_count = 2147483646");
+      return;
+    }
+    const halfSplit = Math.floor((this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES) / 2);
+    const journalReserve = Math.min(MAX_ROLLBACK_JOURNAL_RESERVE_BYTES, halfSplit);
+    const mainBudget = this.maxBytes - SQLITE_FIXED_OVERHEAD_BYTES - journalReserve;
+    if (mainBudget < MIN_SQLITE_PAGE_BUDGET_BYTES) {
+      throw new Error(
+        `maxBytes must be at least ${SQLITE_FIXED_OVERHEAD_BYTES + 2 * MIN_SQLITE_PAGE_BUDGET_BYTES}`
+      );
+    }
+    const maxPages = Math.max(1, Math.floor(mainBudget / this.pageSizeBytes()));
+    this.db.exec(`PRAGMA max_page_count = ${maxPages}`);
+  }
+  /**
+   * Bytes the journal actually occupies: live pages in the main database plus
+   * whatever the rollback/WAL sidecars currently hold.
+   *
+   * The quota MUST be measured this way rather than by `statSync` on the main
+   * database file. SQLite never returns freed pages to the filesystem — it
+   * parks them on the freelist and reuses them — so a database that once grew
+   * large keeps that size forever, even after retention and `maxEvents` have
+   * evicted almost everything. Measuring the file instead wedged the journal
+   * permanently: a 3.9 GB file whose live data was 243 MB failed a 512 MB
+   * quota on EVERY append, and the only escape (`chronicle compact`) refuses
+   * to run while the daemon is up — and the daemon respawns on demand. Live
+   * pages shrink when retention deletes rows, so the quota can recover on its
+   * own; allocated size cannot.
+   *
+   * The sidecars keep their on-disk size: they are transient and genuinely
+   * bounded by `configureByteQuota`'s half-of-budget split.
+   */
+  aggregateLiveBytes() {
+    let total = 0;
+    for (const file of [`${this.dbPath}-journal`, `${this.dbPath}-wal`, `${this.dbPath}-shm`]) {
+      try {
+        total += fs9.statSync(file).size;
+      } catch (error) {
+        if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+      }
+    }
+    return total + this.mainDatabaseLiveBytes();
+  }
+  /** Live (non-freelist) pages of the main database, in bytes. */
+  mainDatabaseLiveBytes() {
+    const pageCount = Number(
+      this.db.prepare("PRAGMA page_count").get().page_count
+    );
+    const freelist = Number(
+      this.db.prepare("PRAGMA freelist_count").get().freelist_count
+    );
+    return Math.max(0, pageCount - freelist) * this.pageSizeBytes();
+  }
+  /** Page size never changes for an open database; resolve it once. */
+  pageSizeBytes() {
+    if (this.cachedPageSize === void 0) {
+      this.cachedPageSize = Number(
+        this.db.prepare("PRAGMA page_size").get().page_size
+      );
+    }
+    return this.cachedPageSize;
+  }
+  normalizeQuotaError(error) {
+    if (this.maxBytes === void 0 || !(error instanceof Error)) return error;
+    const sqliteError = error;
+    const quotaExhausted = sqliteError.code === "SQLITE_FULL" || sqliteError.code === 13 || sqliteError.errcode === 13 || /database or disk is full/i.test(sqliteError.message);
+    if (!quotaExhausted) return error;
+    return new ChronicleStorageQuotaError({
+      currentBytes: this.aggregateLiveBytes(),
+      batchBytes: 0,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  assertActualAllocationWithinQuota() {
+    if (this.maxBytes === void 0) return;
+    const currentBytes = this.aggregateLiveBytes();
+    if (currentBytes <= this.maxBytes) return;
+    throw new ChronicleStorageQuotaError({
+      currentBytes,
+      batchBytes: 0,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  assertWithinByteQuota(events) {
+    if (this.maxBytes === void 0) return;
+    const currentBytes = this.aggregateLiveBytes();
+    const batchBytes = Buffer.byteLength(JSON.stringify(events), "utf8");
+    if (currentBytes + batchBytes <= this.maxBytes) return;
+    throw new ChronicleStorageQuotaError({
+      currentBytes,
+      batchBytes,
+      maxBytes: this.maxBytes,
+      path: this.dbPath
+    });
+  }
+  enforceEventLimitWithinTransaction() {
+    const row = this.db.prepare("SELECT COUNT(*) AS count FROM events").get();
+    if (this.maxEvents === void 0 || row.count <= this.maxEvents) return row.count;
+    const excess = row.count - this.maxEvents;
+    const boundary = this.db.prepare("SELECT day, sequence, hash FROM events ORDER BY day, sequence LIMIT 1 OFFSET ?").get(excess - 1);
+    if (!boundary) return row.count;
+    this.db.prepare(
+      `INSERT INTO chain_checkpoint (day, sequence, hash) VALUES (?, ?, ?)
+         ON CONFLICT(day) DO UPDATE SET sequence = excluded.sequence, hash = excluded.hash`
+    ).run(boundary.day, boundary.sequence, boundary.hash);
+    this.db.prepare("DELETE FROM events WHERE day < ? OR (day = ? AND sequence <= ?)").run(boundary.day, boundary.day, boundary.sequence);
+    this.db.prepare("DELETE FROM chain_checkpoint WHERE day < ?").run(boundary.day);
+    this.anchors.clear();
+    return this.maxEvents;
+  }
+  enforceEventLimitAtStartup() {
+    if (this.maxEvents === void 0 || this.retainedEventCount <= this.maxEvents) return;
+    try {
+      this.db.exec("BEGIN IMMEDIATE");
+      const retainedCount = this.enforceEventLimitWithinTransaction();
+      this.db.exec("COMMIT");
+      this.retainedEventCount = retainedCount;
+    } catch (error) {
+      try {
+        this.db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+  }
   /**
    * Drop events older than the retention window.
    *
@@ -4198,6 +4397,7 @@ var ChronicleSqliteJournal = class {
       };
     }
     this.anchors.clear();
+    this.retainedEventCount = Math.max(0, this.retainedEventCount - count);
     return { ...empty, deletedCount: count };
   }
   /**
@@ -4229,7 +4429,9 @@ var ChronicleSqliteJournal = class {
          ON CONFLICT(day) DO UPDATE SET sequence = excluded.sequence, hash = excluded.hash`
     );
     this.db.exec("BEGIN IMMEDIATE");
+    let retainedCountAfterCommit = this.retainedEventCount;
     try {
+      this.assertWithinByteQuota([]);
       await load({
         insert: (day, event) => {
           const row = projectEvent(event);
@@ -4259,16 +4461,19 @@ var ChronicleSqliteJournal = class {
           checkpoint.run(day, sequence, hash);
         }
       });
+      retainedCountAfterCommit = this.enforceEventLimitWithinTransaction();
+      this.assertActualAllocationWithinQuota();
       this.db.exec("COMMIT");
     } catch (error) {
       try {
         this.db.exec("ROLLBACK");
       } catch {
       }
-      throw error;
+      throw this.normalizeQuotaError(error);
     } finally {
       this.anchors.clear();
     }
+    this.retainedEventCount = retainedCountAfterCommit;
   }
   /**
    * A read engine over this journal's own connection.
@@ -4451,7 +4656,7 @@ function parseArgs(argv) {
     projectId: values.get("--project-id"),
     projectDir: path15.resolve(values.get("--project-dir")),
     workspaceId: values.get("--workspace-id"),
-    retentionDays: Number.isFinite(retentionInput) && retentionInput >= 0 ? retentionInput : 30
+    retentionDays: Number.isFinite(retentionInput) && retentionInput > 0 ? retentionInput : 30
   };
 }
 useDaemonPerfDefaults();
@@ -4524,7 +4729,16 @@ var quarantinedFamilies = [];
 function store() {
   sqliteStore ??= (async () => {
     await fsp4.mkdir(chronicleDirectory, { recursive: true });
-    const journal = new ChronicleSqliteJournal({ directory: chronicleDirectory });
+    const journal = new ChronicleSqliteJournal({
+      directory: chronicleDirectory,
+      retentionDays: parsed.retentionDays,
+      // Bound burst growth independently of age retention. Prefix eviction keeps
+      // at most this many rows while preserving chain verification via checkpoints.
+      maxEvents: 1e5,
+      // Formal aggregate allocation ceiling. Quota-enabled journals reserve
+      // rollback-journal headroom and constrain the main database with max_page_count.
+      maxBytes: 512 * 1024 * 1024
+    });
     try {
       const result = await importLegacyChronicleJournal(journal, chronicleDirectory);
       quarantinedFamilies = result.quarantined;
@@ -4734,18 +4948,32 @@ async function dispatch(op, rawArgs) {
     }
   }
 }
-function send(state, message) {
-  if (state.socket.destroyed) return;
+function encodeResponse(state, message) {
+  if (state.socket.destroyed) return void 0;
   const encoded = encodeChronicleProjectServerMessage(message);
   if (encoded.length > CHRONICLE_PROJECT_SERVER_MAX_FRAME_CHARS) {
     state.socket.destroy(new Error("Chronicle project server response exceeded frame limit"));
-    return;
+    return void 0;
   }
   if (state.socket.writableLength > MAX_CLIENT_WRITE_BUFFER_BYTES) {
     state.socket.destroy(new Error("Chronicle client fell too far behind on reads"));
-    return;
+    return void 0;
   }
-  state.socket.write(encoded);
+  return encoded;
+}
+function send(state, message) {
+  const encoded = encodeResponse(state, message);
+  if (encoded !== void 0) state.socket.write(encoded);
+}
+async function sendAcknowledgement(state, message) {
+  const encoded = encodeResponse(state, message);
+  if (encoded === void 0) throw new Error("Chronicle client disconnected before acknowledgement");
+  await new Promise((resolve12, reject) => {
+    state.socket.write(encoded, (error) => {
+      if (error) reject(error);
+      else resolve12();
+    });
+  });
 }
 async function handleMessage(state, message) {
   if (message.authToken !== authToken) {
@@ -4759,7 +4987,12 @@ async function handleMessage(state, message) {
     return;
   }
   if (message.type === "shutdown") {
-    send(state, { type: "response", id: message.id, ok: true, result: { stopped: true } });
+    await sendAcknowledgement(state, {
+      type: "response",
+      id: message.id,
+      ok: true,
+      result: { stopped: true }
+    });
     await stop(message.reason ?? "client request");
     return;
   }
@@ -4829,9 +5062,14 @@ async function stop(_reason) {
   if (idleTimer) clearTimeout(idleTimer);
   idleTimer = void 0;
   await removeOwnedMetadata();
-  await new Promise((resolve12) => server.close(() => resolve12()));
   for (const state of clients) state.socket.destroy();
   clients.clear();
+  await new Promise((resolve12, reject) => {
+    server.close((error) => {
+      if (error) reject(error);
+      else resolve12();
+    });
+  });
   await watcher?.close().catch(() => {
   });
   watcher = void 0;
@@ -4882,7 +5120,7 @@ server.on("error", (error) => {
     probe.once("error", () => {
       probe.destroy();
       try {
-        fs9.rmSync(endpoint, { force: true });
+        fs10.rmSync(endpoint, { force: true });
       } catch {
       }
       probingExistingEndpoint = false;
@@ -4895,7 +5133,7 @@ server.on("error", (error) => {
 server.on("listening", () => {
   if (process.platform !== "win32") {
     try {
-      fs9.chmodSync(endpoint, 384);
+      fs10.chmodSync(endpoint, 384);
     } catch {
     }
   }

package/dist/chronicle/sqlite-compaction.d.ts

@@ -0,0 +1,20 @@
+export interface ChronicleSqliteCompactionOptions {
+    dbPath: string;
+    endpointMetadataPath?: string;
+}
+export interface ChronicleSqliteCompactionResult {
+    beforeBytes: number;
+    afterBytes: number;
+    reclaimedBytes: number;
+}
+export declare class ChronicleCompactionBusyError extends Error {
+    constructor(pid: number);
+}
+/** Aggregate allocated bytes for the SQLite database and its WAL/SHM sidecars. */
+export declare function chronicleSqliteAllocatedBytes(dbPath: string): number;
+/**
+ * Reclaim free SQLite pages. The caller must keep the Chronicle project server
+ * stopped for the entire operation; this function refuses known live servers.
+ */
+export declare function compactChronicleSqlite(options: ChronicleSqliteCompactionOptions): ChronicleSqliteCompactionResult;
+//# sourceMappingURL=sqlite-compaction.d.ts.map

package/dist/chronicle/sqlite-journal.d.ts

@@ -6,12 +6,31 @@ export declare const CHRONICLE_SQLITE_FILE = "chronicle.sqlite";
 export declare const LEGACY_JSONL_MIGRATION_KEY = "legacy-jsonl-v1";
 /** Day families the import refused to move, recorded so they are never retried silently. */
 export declare const LEGACY_JSONL_QUARANTINE_KEY = "legacy-jsonl-v1:quarantine";
+export declare class ChronicleStorageQuotaError extends Error {
+    readonly currentBytes: number;
+    readonly batchBytes: number;
+    readonly maxBytes: number;
+    readonly path: string;
+    constructor(details: {
+        currentBytes: number;
+        batchBytes: number;
+        maxBytes: number;
+        path: string;
+    });
+}
 export interface ChronicleSqliteJournalOptions {
     /** Directory holding the journal, i.e. `<projectDir>/chronicle`. */
     directory: string;
     now?: (() => Date) | undefined;
     monotonicNow?: (() => bigint) | undefined;
     idFactory?: (() => string) | undefined;
+    /** Optional age bound, enforced during periodic maintenance. */
+    retentionDays?: number | undefined;
+    /** Optional row ceiling; oldest rows are checkpointed and evicted after each append. */
+    maxEvents?: number | undefined;
+    /** Aggregate SQLite allocation ceiling across the database, WAL, and SHM files. */
+    maxBytes?: number | undefined;
+    retentionCheckIntervalMs?: number | undefined;
 }
 export interface ChronicleSqlitePurgeOptions {
     retentionDays: number;
@@ -43,6 +62,14 @@ export declare class ChronicleSqliteJournal {
     private readonly now;
     private readonly monotonicNow;
     private readonly idFactory;
+    private readonly retentionDays;
+    private readonly maxEvents;
+    private readonly maxBytes;
+    private readonly retentionCheckIntervalMs;
+    private nextRetentionCheckAt;
+    private retainedEventCount;
+    /** Resolved lazily by `pageSizeBytes()`; constant for an open database. */
+    private cachedPageSize;
     /**
      * Cached chain head per day. Cleared wholesale on any write failure so the
      * next append rebuilds from the database rather than trusting a counter that
@@ -83,6 +110,36 @@ export declare class ChronicleSqliteJournal {
      * an in-place edit that left the links intact.
      */
     verify(): Promise<ChronicleVerifyResult>;
+    private enforceRetentionIfDue;
+    private configureByteQuota;
+    /**
+     * Bytes the journal actually occupies: live pages in the main database plus
+     * whatever the rollback/WAL sidecars currently hold.
+     *
+     * The quota MUST be measured this way rather than by `statSync` on the main
+     * database file. SQLite never returns freed pages to the filesystem — it
+     * parks them on the freelist and reuses them — so a database that once grew
+     * large keeps that size forever, even after retention and `maxEvents` have
+     * evicted almost everything. Measuring the file instead wedged the journal
+     * permanently: a 3.9 GB file whose live data was 243 MB failed a 512 MB
+     * quota on EVERY append, and the only escape (`chronicle compact`) refuses
+     * to run while the daemon is up — and the daemon respawns on demand. Live
+     * pages shrink when retention deletes rows, so the quota can recover on its
+     * own; allocated size cannot.
+     *
+     * The sidecars keep their on-disk size: they are transient and genuinely
+     * bounded by `configureByteQuota`'s half-of-budget split.
+     */
+    private aggregateLiveBytes;
+    /** Live (non-freelist) pages of the main database, in bytes. */
+    private mainDatabaseLiveBytes;
+    /** Page size never changes for an open database; resolve it once. */
+    private pageSizeBytes;
+    private normalizeQuotaError;
+    private assertActualAllocationWithinQuota;
+    private assertWithinByteQuota;
+    private enforceEventLimitWithinTransaction;
+    private enforceEventLimitAtStartup;
     /**
      * Drop events older than the retention window.
      *

package/dist/coordination/agents/capability-manifest.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compatibility export for callers that historically loaded the runtime
+ * capability contract from the agent catalog. The contract itself lives in
+ * `types/` so low-level prompt composition does not depend on coordination.
+ */
+export * from '../../types/runtime-capability-manifest.js';
+//# sourceMappingURL=capability-manifest.d.ts.map

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

@@ -24,13 +24,14 @@ 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';
-export * from './role-skills.js';
-export * 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-identity.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, };
 /** Every catalog agent, in phase order, enriched with its curated skills. */
 export declare const ALL_AGENT_DEFINITIONS: AgentDefinition[];