@theokit/sdk 4.57.0 → 4.59.0

package/dist/{chunk-UPRJR6IP.js → chunk-UCBJBJ27.js}

@@ -1,8 +1,6 @@
 import { atomicWriteJson } from './chunk-VF7EWVDG.js';
 import { diag } from './chunk-T7O6K6PX.js';
 import { readFile, rename } from 'fs/promises';
-import { homedir } from 'os';
-import { join } from 'path';
 
 function migrateSchema(opts) {
   const { db, currentVersion, migrations, label = "db" } = opts;
@@ -77,27 +75,7 @@ async function writeVersionedJson(path, data, currentVersion) {
   };
   await atomicWriteJson(path, file);
 }
-var THEOKIT_DIR_NAME = ".theokit";
-function getTheokitHome(cwd) {
-  const override = process.env.THEOKIT_HOME?.trim();
-  if (override !== void 0 && override.length > 0) {
-    return override;
-  }
-  return join(cwd, THEOKIT_DIR_NAME);
-}
-function getProfilesRoot() {
-  return join(homedir(), THEOKIT_DIR_NAME, "profiles");
-}
-function displayTheokitHome(cwd) {
-  const resolved = getTheokitHome(cwd);
-  const home = homedir();
-  if (resolved === home) return "~";
-  if (resolved.startsWith(`${home}/`)) {
-    return `~${resolved.slice(home.length)}`;
-  }
-  return resolved;
-}
 
-export { displayTheokitHome, getProfilesRoot, getTheokitHome, migrateSchema, readVersionedJson, writeVersionedJson };
-//# sourceMappingURL=chunk-UPRJR6IP.js.map
-//# sourceMappingURL=chunk-UPRJR6IP.js.map
+export { migrateSchema, readVersionedJson, writeVersionedJson };
+//# sourceMappingURL=chunk-UCBJBJ27.js.map
+//# sourceMappingURL=chunk-UCBJBJ27.js.map

package/dist/chunk-UCBJBJ27.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/persistence/schema-version.ts"],"names":[],"mappings":"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","file":"chunk-UCBJBJ27.js","sourcesContent":["/**\n * Schema versioning helpers (ADR D62).\n *\n * Two parallel APIs:\n *   - `migrateSchema` — SQLite via `PRAGMA user_version` + ordered forward-only migrations.\n *   - `readVersionedJson` / `writeVersionedJson` — JSON files with `_schemaVersion` field.\n *\n * Forward-only: never deletes data, never downgrades. Migration callbacks\n * own the transformation; this module owns the bookkeeping.\n *\n * @internal\n */\n\nimport { readFile, rename } from \"node:fs/promises\";\nimport { diag } from \"../diagnostics.js\";\nimport { atomicWriteJson } from \"./atomic-write.js\";\n\n// ────────────────────── SQLite migrations ──────────────────────\n\n/**\n * The three `better-sqlite3` methods this module actually uses, declared structurally so nothing\n * here imports the driver.\n *\n * A real `better-sqlite3` `Database` satisfies it. `pragma` is called both to read\n * (`pragma(\"user_version\", { simple: true })`, which must return the number itself rather than a\n * row array) and to write (`pragma(\"user_version = N\")`). `transaction` must return a function\n * that, when called, runs the wrapped body inside a real SQLite transaction and rolls it back if\n * the body throws — a stub that merely calls through gives `migrateSchema` no atomicity, and a\n * half-applied migration is exactly what it exists to prevent.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport interface SqliteLike {\n  pragma: (statement: string, options?: { simple?: boolean }) => unknown;\n  exec: (sql: string) => void;\n  transaction: <Args extends unknown[], R>(fn: (...args: Args) => R) => (...args: Args) => R;\n}\n\n/**\n * One forward migration step.\n *\n * `up` runs inside the shared transaction and must be self-contained: it may not commit, and any\n * error it throws aborts the whole run and rolls back every step in it, including the ones that\n * already succeeded. `user_version` is set to `toVersion` immediately after `up` returns, inside\n * the same transaction, so version and schema move together or not at all.\n *\n * `toVersion` is the version the database reaches, not the one it starts from. Steps are ordered\n * by it, gaps are allowed, and two steps sharing a `toVersion` both run — nothing deduplicates\n * them.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport interface Migration {\n  toVersion: number;\n  up: (db: SqliteLike) => void;\n}\n\n/**\n * Arguments to `migrateSchema`.\n *\n * `currentVersion` is the version the code expects, and it is the ceiling: a migration whose\n * `toVersion` exceeds it is left unapplied for a later release. `migrations` may be given in any\n * order and may contain steps already applied — both are filtered and sorted here. `label` only\n * ever appears in the downgrade error message.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport interface MigrateSchemaOptions {\n  db: SqliteLike;\n  currentVersion: number;\n  migrations: ReadonlyArray<Migration>;\n  /** For log/error context (e.g., \"memory-index\", \"registry\"). */\n  label?: string;\n}\n\n/**\n * What `migrateSchema` did.\n *\n * `from` is the `user_version` found on the database, `to` is the version it holds afterwards,\n * and `ran` is how many steps executed. When nothing was pending, `to === from` and `ran === 0`.\n *\n * `to` is the `toVersion` of the last step applied, NOT `currentVersion`. A database at version 3\n * against `currentVersion: 5` with no migration in that range comes back as\n * `{ from: 3, to: 3, ran: 0 }` — the gap is reported, not closed. Comparing `to` with\n * `currentVersion` is how a caller notices that the migration list is missing a step.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport interface MigrateSchemaResult {\n  from: number;\n  to: number;\n  ran: number;\n}\n\n/**\n * Bring a SQLite database's `user_version` up to `currentVersion` by running the steps that sit\n * between the two.\n *\n * Steps are sorted ascending by `toVersion` and filtered to `> stored && <= currentVersion`, then\n * run in that order inside ONE transaction: each `up` is followed immediately by the matching\n * `user_version` write. Either every step in the run commits or none does — a step that throws\n * aborts the transaction, propagates the error, and leaves the database at the version it started\n * from. There is no partially-migrated state and no resume point.\n *\n * Forward-only. When the stored version is greater than `currentVersion` — an older build opening\n * a database a newer one already migrated — this throws immediately, before touching anything,\n * with a message naming both versions and `label`. Nothing downgrades, and no data is deleted on\n * any path here; what a step does is the step's own business.\n *\n * A stored version equal to `currentVersion` returns without opening a transaction. A `user_version`\n * that is absent or not a number is read as 0, so a fresh database runs every step.\n *\n * Concurrency: the SQLite transaction is the only serialization. This takes no file lock, so two\n * processes migrating the same file at once are arbitrated by SQLite's own write lock — the loser\n * gets a busy or locked error from the driver, not a queued turn. Wrap the call in `withFileLock`\n * if that matters.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport function migrateSchema(opts: MigrateSchemaOptions): MigrateSchemaResult {\n  const { db, currentVersion, migrations, label = \"db\" } = opts;\n  const storedRaw = db.pragma(\"user_version\", { simple: true });\n  const stored = typeof storedRaw === \"number\" ? storedRaw : 0;\n\n  if (stored > currentVersion) {\n    throw new Error(\n      `[${label}] schema version ${stored} > current ${currentVersion}; ` +\n        \"did you downgrade the SDK? Forward-only migrations only.\",\n    );\n  }\n\n  if (stored === currentVersion) {\n    return { from: stored, to: stored, ran: 0 };\n  }\n\n  const pending = [...migrations]\n    .sort((a, b) => a.toVersion - b.toVersion)\n    .filter((m) => m.toVersion > stored && m.toVersion <= currentVersion);\n\n  let ran = 0;\n  let lastApplied = stored;\n\n  db.transaction(() => {\n    for (const m of pending) {\n      m.up(db);\n      db.pragma(`user_version = ${m.toVersion}`);\n      lastApplied = m.toVersion;\n      ran += 1;\n    }\n  })();\n\n  return { from: stored, to: lastApplied, ran };\n}\n\n// ────────────────────── JSON versioned files ──────────────────────\n\n/**\n * The on-disk envelope: the payload under `data`, its schema version alongside it.\n *\n * `writeVersionedJson` always produces this shape. `readVersionedJson` reads it, but tolerates a\n * file that is not in it — a legacy object with no `_schemaVersion` is treated as version 0 and\n * handed to the migrate callback whole, so this type describes what is written, not everything\n * that can be read.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport interface VersionedJsonFile<T> {\n  _schemaVersion: number;\n  data: T;\n}\n\n/**\n * Upgrade callback for `readVersionedJson`, invoked only when the stored version is BELOW the\n * current one.\n *\n * `parsed` is the whole parsed JSON value, not `parsed.data`. That is deliberate: a legacy file\n * predating the envelope has its fields at the top level, and a callback handed only `.data`\n * would receive `undefined` for exactly the files that need migrating. It is typed `unknown`\n * because nothing has validated it — narrow before reading.\n *\n * `fromVersion` is the `_schemaVersion` found on disk, or 0 when the field is missing or not a\n * number.\n *\n * The return value is used as-is and is NOT written back; the file on disk still holds the old\n * shape until someone calls `writeVersionedJson`. Throwing here propagates out of\n * `readVersionedJson`, which otherwise never throws — return the default value instead if an\n * unmigratable file should be survivable.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport type VersionedJsonMigrate<T> = (parsed: unknown, fromVersion: number) => T;\n\n/**\n * Arguments to `readVersionedJson`.\n *\n * `defaultValue` is a factory rather than a value because it is called on several paths and each\n * caller must get its own object — returning a shared mutable default would let one caller's\n * edits appear in another's. It is called for a missing file, an unreadable one, a corrupt one,\n * a non-object payload, and a file written by a newer version.\n *\n * `migrate` is called only for a stored version strictly below `currentVersion`.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport interface ReadVersionedJsonOptions<T> {\n  path: string;\n  currentVersion: number;\n  migrate: VersionedJsonMigrate<T>;\n  defaultValue: () => T;\n}\n\n/**\n * Read a versioned JSON file, migrating or falling back rather than failing.\n *\n * What comes back, by case:\n *\n *   - version matches `currentVersion` — the file's `data` field, returned as `T` WITHOUT\n *     validation. A file whose envelope is right but whose payload is not gets through.\n *   - version below `currentVersion` — whatever `migrate(parsed, stored)` returns. The migrated\n *     value is not persisted; the file is untouched.\n *   - version above `currentVersion` — `defaultValue()`, plus a warning. Forward-only: a file\n *     written by a newer build is left alone rather than downgraded.\n *   - file missing, or unreadable for any other reason (permissions, a directory in its place) —\n *     `defaultValue()`, silently. Absence and denial are not distinguished.\n *   - file present but not valid JSON — `defaultValue()`, and the file is RENAMED to\n *     `<path>.corrupt.<epoch-ms>` so the next run starts clean and the bad bytes stay available.\n *     A rename that itself fails is warned about and the read still returns the default, which\n *     means the same corrupt file will be met again next time.\n *   - JSON that parses to a non-object (a number, a string, `null`) — `defaultValue()`, silently\n *     and without moving the file aside.\n *\n * The only ways this throws are through the callbacks you supply: `migrate` or `defaultValue`\n * raising. Nothing else here rejects.\n *\n * There is no locking. A concurrent `writeVersionedJson` on the same path is atomic at the rename,\n * so a reader sees either the old file or the new one, never a half-written one — but a\n * read-modify-write built from this pair is NOT atomic across the two calls, and needs\n * `withFileLock` around both.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport async function readVersionedJson<T>(opts: ReadVersionedJsonOptions<T>): Promise<T> {\n  const { path, currentVersion, migrate, defaultValue } = opts;\n\n  let raw: string;\n  try {\n    raw = await readFile(path, \"utf-8\");\n  } catch {\n    return defaultValue();\n  }\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch {\n    // T5.10 — move corrupt file aside so (a) user can investigate and\n    // (b) next run starts fresh instead of hitting the same warning loop.\n    const asidePath = `${path}.corrupt.${Date.now()}`;\n    try {\n      await rename(path, asidePath);\n      diag(`[theokit-sdk] ${path} is corrupt; moved to ${asidePath}. Using default value.\\n`);\n    } catch {\n      diag(`[theokit-sdk] ${path} is corrupt; using default value.\\n`);\n    }\n    return defaultValue();\n  }\n\n  if (typeof parsed !== \"object\" || parsed === null) {\n    return defaultValue();\n  }\n\n  const file = parsed as { _schemaVersion?: unknown; data?: unknown };\n  const storedRaw = file._schemaVersion;\n  const stored = typeof storedRaw === \"number\" ? storedRaw : 0;\n\n  if (stored === currentVersion) {\n    return file.data as T;\n  }\n\n  if (stored > currentVersion) {\n    diag(\n      `[theokit-sdk] ${path} schema version ${stored} > current ${currentVersion}; ` +\n        \"using default value (forward-only).\\n\",\n    );\n    return defaultValue();\n  }\n\n  // EC-2 fix: pass the FULL parsed object to migrate, not just `file.data`.\n  // Legacy shapes (e.g., `{ schemaVersion: \"1.0\", agents: {...} }` without\n  // a `data` field) need to inspect the whole thing.\n  return migrate(parsed, stored);\n}\n\n/**\n * Write `data` wrapped in the version envelope, replacing the file atomically.\n *\n * The bytes go to a temp file in the same directory and are moved into place with `rename`, so a\n * crash or a concurrent reader never observes a partial file: the path holds either the previous\n * content or the complete new content. Parent directories are created as needed, and the file is\n * created with mode 0600 (subject to the process umask), formatted with two-space indentation and\n * a trailing newline.\n *\n * `currentVersion` is stamped verbatim as `_schemaVersion`; nothing checks it against what was\n * already on disk, so this will happily overwrite a newer file with an older version. Read first\n * if that matters.\n *\n * Rejects when `data` cannot be serialized — a circular reference, or a `toJSON` that throws.\n * Serialization happens before any filesystem call, so on that path no directory is created, no\n * temp file exists, and the file already on disk is untouched.\n *\n * Atomicity is the rename's, so it is as strong as the filesystem's: on NFS, SMB or FUSE the\n * underlying writer emits a one-shot warning that the guarantee is weaker there.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport async function writeVersionedJson<T>(\n  path: string,\n  data: T,\n  currentVersion: number,\n): Promise<void> {\n  const file: VersionedJsonFile<T> = {\n    _schemaVersion: currentVersion,\n    data,\n  };\n  await atomicWriteJson(path, file);\n}\n"]}

package/dist/chunk-UFLD2HEV.js

@@ -0,0 +1,35 @@
+import { homedir } from 'os';
+import { join } from 'path';
+
+// src/internal/persistence/paths.ts
+var THEOKIT_DIR_LITERAL = ".theokit";
+var CLAUDE_DIR_NAME = ".claude";
+function getTheokitHome(cwd) {
+  const override = process.env.THEOKIT_HOME?.trim();
+  if (override !== void 0 && override.length > 0) {
+    return override;
+  }
+  return join(cwd, THEOKIT_DIR_LITERAL);
+}
+function projectConfigRoots(cwd) {
+  return [join(cwd, THEOKIT_DIR_LITERAL), join(cwd, CLAUDE_DIR_NAME)];
+}
+function pluginBundleRoots(cwd) {
+  return projectConfigRoots(cwd).map((root) => join(root, "plugins"));
+}
+function getProfilesRoot() {
+  return join(homedir(), THEOKIT_DIR_LITERAL, "profiles");
+}
+function displayTheokitHome(cwd) {
+  const resolved = getTheokitHome(cwd);
+  const home = homedir();
+  if (resolved === home) return "~";
+  if (resolved.startsWith(`${home}/`)) {
+    return `~${resolved.slice(home.length)}`;
+  }
+  return resolved;
+}
+
+export { displayTheokitHome, getProfilesRoot, getTheokitHome, pluginBundleRoots, projectConfigRoots };
+//# sourceMappingURL=chunk-UFLD2HEV.js.map
+//# sourceMappingURL=chunk-UFLD2HEV.js.map

package/dist/chunk-UFLD2HEV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/persistence/paths.ts"],"names":[],"mappings":";;;;AAuCA,IAAM,mBAAA,GAAsB,UAAA;AAG5B,IAAM,eAAA,GAAkB,SAAA;AAuBjB,SAAS,eAAe,GAAA,EAAqB;AAClD,EAAA,MAAM,QAAA,GAAW,OAAA,CAAQ,GAAA,CAAI,YAAA,EAAc,IAAA,EAAK;AAChD,EAAA,IAAI,QAAA,KAAa,MAAA,IAAa,QAAA,CAAS,MAAA,GAAS,CAAA,EAAG;AACjD,IAAA,OAAO,QAAA;AAAA,EACT;AACA,EAAA,OAAO,IAAA,CAAK,KAAK,mBAAmB,CAAA;AACtC;AA6BO,SAAS,mBAAmB,GAAA,EAAuB;AACxD,EAAA,OAAO,CAAC,KAAK,GAAA,EAAK,mBAAmB,GAAG,IAAA,CAAK,GAAA,EAAK,eAAe,CAAC,CAAA;AACpE;AAeO,SAAS,kBAAkB,GAAA,EAAuB;AACvD,EAAA,OAAO,kBAAA,CAAmB,GAAG,CAAA,CAAE,GAAA,CAAI,CAAC,IAAA,KAAS,IAAA,CAAK,IAAA,EAAM,SAAS,CAAC,CAAA;AACpE;AAeO,SAAS,eAAA,GAA0B;AACxC,EAAA,OAAO,IAAA,CAAK,OAAA,EAAQ,EAAG,mBAAA,EAAqB,UAAU,CAAA;AACxD;AAmBO,SAAS,mBAAmB,GAAA,EAAqB;AACtD,EAAA,MAAM,QAAA,GAAW,eAAe,GAAG,CAAA;AACnC,EAAA,MAAM,OAAO,OAAA,EAAQ;AACrB,EAAA,IAAI,QAAA,KAAa,MAAM,OAAO,GAAA;AAC9B,EAAA,IAAI,QAAA,CAAS,UAAA,CAAW,CAAA,EAAG,IAAI,GAAG,CAAA,EAAG;AACnC,IAAA,OAAO,CAAA,CAAA,EAAI,QAAA,CAAS,KAAA,CAAM,IAAA,CAAK,MAAM,CAAC,CAAA,CAAA;AAAA,EACxC;AACA,EAAA,OAAO,QAAA;AACT","file":"chunk-UFLD2HEV.js","sourcesContent":["/**\n * Path resolution for SDK state files (ADR D60).\n *\n * Theokit anchors state at `<cwd>/.theokit/` by default (per-cwd). An\n * optional `THEOKIT_HOME` environment variable overrides this, enabling\n * test isolation, profile switching, and multi-tenant deployments.\n *\n * Rules:\n *   - `getTheokitHome(cwd)` is the canonical resolver **for cwd-anchored state**. Never hardcode\n *     `path.join(cwd, \".theokit\")` in callers — use this function so tests\n *     and overrides stay consistent.\n *\n *     M94 — this comment said \"the ONLY canonical resolver\", and stopped being true: the\n *     transcript gained `transcriptRoot()`, which is **home-anchored** (`~/.theokit`) with the same\n *     `THEOKIT_HOME` override. The two defaults differ on purpose — unifying would move the\n *     transcript of everyone who does NOT set the variable, which is a data migration and not a\n *     re-export.\n *\n *     A consequence worth writing down: **without `THEOKIT_HOME` the state stays split in two**\n *     — registry in `<cwd>/.theokit`, transcript in `~/.theokit`. M94 unifies only for those who set\n *     the variable. Unifying both defaults is another milestone's work.\n *   - `getProfilesRoot()` is intentionally home-anchored (not affected by\n *     `THEOKIT_HOME`) so `theokit profile list` discovers all profiles\n *     regardless of which is active.\n *   - `displayTheokitHome(cwd)` returns a human-readable path for logs.\n *\n * @internal\n */\n\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\n\n/**\n * The project config directory literal.\n *\n * Renamed from `THEOKIT_DIR_NAME` in #410. Sharing a name with the (now removed) sovereign env var\n * was the MECHANISM of that defect, not scenery: every grep for the variable landed on this const\n * and looked answered, so \"is it read?\" returned five hits and nobody checked what they were.\n */\nconst THEOKIT_DIR_LITERAL = \".theokit\";\n\n/** The Claude Code CLI's project configuration directory. */\nconst CLAUDE_DIR_NAME = \".claude\";\n\n/**\n * Resolve the directory cwd-anchored SDK state lives in.\n *\n * `THEOKIT_HOME` wins when it is set and not blank after trimming; the trimmed value is used, and\n * it is used VERBATIM — it is not resolved against `cwd`, so a relative value stays relative and\n * `.theokit` is not appended to it. Otherwise the answer is `<cwd>/.theokit`.\n *\n * The environment is read on every call, so a change to the variable takes effect immediately\n * rather than being frozen at import.\n *\n * This creates nothing and checks nothing: the returned path may not exist, and the caller owns\n * the `mkdir`. Call it instead of writing `join(cwd, \".theokit\")` by hand, or the override stops\n * working for that one call site and tests silently touch the real home.\n *\n * Not the whole story about where state lives — the transcript is home-anchored via\n * `transcriptRoot()`, honoring the same variable but defaulting to `~/.theokit`. With\n * `THEOKIT_HOME` unset, state is genuinely split between two roots.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport function getTheokitHome(cwd: string): string {\n  const override = process.env.THEOKIT_HOME?.trim();\n  if (override !== undefined && override.length > 0) {\n    return override;\n  }\n  return join(cwd, THEOKIT_DIR_LITERAL);\n}\n\n/**\n * Every directory a project's configuration may be read from, in precedence order.\n *\n * `.theokit` first, then `.claude`. The order is the whole contract: a project that declares a\n * skill, agent or rule in both means the explicit namespace to win, and a caller merging these\n * roots must therefore keep the FIRST occurrence of a name rather than the last.\n *\n * `.claude` is read because the formats already agree and only the location did not. Measured\n * 2026-08-26: the SKILL.md frontmatter this SDK requires (`name` + `description`) is exactly what\n * the CLI writes, its hook config is the same JSON shape, and 59 of the CLI's agent declarations\n * parse here unchanged. A repository set up for the CLI was failing on the directory name alone.\n *\n * NOT a rename of `.theokit`, and not a migration. Both are read, so nothing that works today stops\n * working — which is why this returns a LIST and not a single resolved answer.\n *\n * Deliberately NOT affected by `THEOKIT_HOME`, and this is the one thing to remember about it.\n * That variable relocates cwd-anchored SDK *state* — sessions, the credential store. A project's\n * *configuration* is a property of the repository, not of where this SDK keeps its state, and the\n * loaders that read these directories have always anchored on `cwd` directly. Honouring the\n * override here would silently move where a project's agents and skills come from, which is a\n * behaviour change wearing the costume of a refactor.\n *\n * Creates nothing and checks nothing; either path may not exist, and the caller owns that.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport function projectConfigRoots(cwd: string): string[] {\n  return [join(cwd, THEOKIT_DIR_LITERAL), join(cwd, CLAUDE_DIR_NAME)];\n}\n\n/**\n * Every directory that may hold a plugin BUNDLE contributed by the Claude Code CLI.\n *\n * A CLI plugin is not a JS entry point — it is a folder whose `skills/` and `agents/` are what it\n * exists to provide. Measured 2026-08-26 on an installed one: seven agents and three skills beside\n * a manifest in `.claude-plugin/plugin.json`. Parsing that manifest and stopping there produced a\n * plugin that loaded and did nothing.\n *\n * Project-scoped deliberately. The CLI also keeps plugins under `~/.claude/plugins/cache`, behind\n * its own installer and enable/disable state — reproducing that is an installation system, not\n * reading a project's configuration, and guessing at someone's enablement would run code they\n * turned off.\n */\nexport function pluginBundleRoots(cwd: string): string[] {\n  return projectConfigRoots(cwd).map((root) => join(root, \"plugins\"));\n}\n\n/**\n * The directory holding every profile: always `~/.theokit/profiles`, from `os.homedir()`.\n *\n * Deliberately NOT affected by `THEOKIT_HOME`, which is the one thing to remember about it. If it\n * followed the override, a session pointed at one profile would only be able to see that profile,\n * and `theokit profile list` could never enumerate the rest. Profiles are the thing the override\n * switches between, so their index cannot live behind it.\n *\n * Takes no `cwd` for the same reason. Creates nothing; the path may not exist.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport function getProfilesRoot(): string {\n  return join(homedir(), THEOKIT_DIR_LITERAL, \"profiles\");\n}\n\n/**\n * The same path `getTheokitHome(cwd)` returns, shortened for display: the home directory prefix\n * collapses to `~`, so `/home/ada/.theokit` prints as `~/.theokit`.\n *\n * For humans only — log lines, CLI output, error messages. The result is NOT a usable path: `~`\n * is a shell convention that `fs` does not expand, so passing this to a filesystem call resolves\n * a literal directory named `~` relative to the process cwd. Use `getTheokitHome` for anything\n * that touches disk.\n *\n * Collapsing is a prefix match on the home directory followed by a literal `/`, so a sibling like\n * `/home/adalovelace` is left alone even though `/home/ada` is a string prefix of it. A path\n * outside the home directory comes back unchanged — and so does a Windows path, where the\n * separator is a backslash and the prefix test therefore never matches.\n *\n * Semver-exempt: reachable via the `@theokit/sdk/internal/persistence` sub-path, which the package\n * declares in `exports` but does NOT cover with its semver contract.\n */\nexport function displayTheokitHome(cwd: string): string {\n  const resolved = getTheokitHome(cwd);\n  const home = homedir();\n  if (resolved === home) return \"~\";\n  if (resolved.startsWith(`${home}/`)) {\n    return `~${resolved.slice(home.length)}`;\n  }\n  return resolved;\n}\n"]}

package/dist/{chunk-GTKFV7O5.js → chunk-WFC26L6Y.js}

@@ -44,6 +44,27 @@ var DEFAULT_DISCOVERY_SPECS = [
     followImports: false,
     priority: 45
   },
+  {
+    // Rules written for the Claude Code CLI. Measured 2026-08-26 over this repository's 32 rule
+    // files: none carries frontmatter, and `rules-frontmatter` already reads a file without it as
+    // `alwaysApply: true` — the format needed nothing, only a spec pointing at the directory.
+    //
+    // 47, not 46. Specs sort ascending and a context budget drops the tail first, so it must land
+    // AFTER `.theokit/rules` (45) — the explicit namespace should survive a squeeze the borrowed one
+    // does not. It must also leave a slot on BOTH sides: B-127 makes these numbers a public contract
+    // precisely so a consumer can place its own source between two defaults, and 46 would have left
+    // no room between 45 and itself. 47 keeps 46 free below and 48–49 free above.
+    //
+    // The reckoning B-127's docblock asks for: no published priority MOVES, so a consumer that chose
+    // 46, 48 or 49 is unaffected. A consumer that had chosen 47 now collides — that is the cost of
+    // an eighth default, paid once and recorded here rather than discovered later.
+    id: "claude-rules",
+    pattern: ".claude/rules/*.md",
+    scope: "globbed",
+    parser: "rules-frontmatter",
+    followImports: false,
+    priority: 47
+  },
   {
     id: "theokit-context",
     pattern: ".theokit/context/*.md",
@@ -124,5 +145,5 @@ async function walkUpForGlob(cwd, pattern) {
 }
 
 export { DEFAULT_DISCOVERY_SPECS, findGitRoot, isSafePattern, walkUpForFile, walkUpForGlob };
-//# sourceMappingURL=chunk-GTKFV7O5.js.map
-//# sourceMappingURL=chunk-GTKFV7O5.js.map
+//# sourceMappingURL=chunk-WFC26L6Y.js.map
+//# sourceMappingURL=chunk-WFC26L6Y.js.map

package/dist/chunk-WFC26L6Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/runtime/context/context-discovery.ts"],"names":[],"mappings":"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","file":"chunk-WFC26L6Y.js","sourcesContent":["/**\n * Context file discovery (T1.1, ADRs D150 / D151).\n *\n * Discovers context files via three scopes:\n *  - `cwd-only` — single dir, single path lookup\n *  - `git-root-walk` — walk cwd → git-root, collect every directory's match\n *    (nearest-first ordering)\n *  - `globbed` — glob pattern relative to cwd (e.g. `.cursor/rules/*.mdc`)\n *\n * Pure `existsSync` checks — **no `.gitignore` parsing** (EC-A, KISS) and\n * **no invented `.theokitignore`** (EC-B). Paths normalized via\n * `realpath` to dedup symlink chains pointing to the same physical file\n * (EC-F). Git worktrees work transparently because `.git` exists as a\n * file in that case (EC-N).\n *\n * @internal\n */\n\nimport { existsSync, realpathSync } from \"node:fs\";\nimport { glob } from \"node:fs/promises\";\nimport { dirname, isAbsolute, join, resolve } from \"node:path\";\n\n/** Single filename (\"AGENTS.md\") or relative glob (\".cursor/rules/*.mdc\"). */\nexport type DiscoveryScope = \"cwd-only\" | \"git-root-walk\" | \"globbed\";\n\n/** Parser to apply once file is read. */\nexport type DiscoveryParser = \"plain-markdown\" | \"mdc\" | \"frontmatter-zod\" | \"rules-frontmatter\";\n\n/**\n * One kind of context file the runner knows how to find and read. The shipped registry is\n * `DEFAULT_DISCOVERY_SPECS`; a caller supplies its own array to change the set.\n *\n * `scope` decides how `pattern` is used and how many files a single spec can yield:\n * `cwd-only` looks for one path and stops, `git-root-walk` collects a match in every directory\n * from `cwd` up to the git root (nearest first), and `globbed` expands `pattern` as a glob\n * relative to `cwd`. So `pattern` is a filename for the first two and a glob for the third —\n * putting a glob on a walk scope silently finds nothing.\n *\n * `priority` orders the merged prompt, ascending, and is a plain number rather than an index, so\n * a new spec can be slotted between two existing ones. Lower means earlier and therefore more\n * general; later content wins on conflict.\n *\n * `parser` must match the file format — `plain-markdown` reads the whole file, `mdc` and\n * `rules-frontmatter` parse frontmatter and can DECLINE the file when its activation conditions\n * do not hold, and `frontmatter-zod` is the legacy path the runner currently skips entirely.\n *\n * `followImports` is honored only by `plain-markdown`, and turns `@path` directives in the body\n * into inlined content bounded by the import root. Setting it on a frontmatter parser does\n * nothing.\n *\n * `id` names the source in `<source name=\"\">` and in telemetry. When one spec matches files in\n * several directories, the runner suffixes it with the path relative to the git root to keep them\n * apart.\n *\n * @public — re-exported from `@theokit/sdk/context`, and therefore under semver.\n */\nexport interface DiscoverySpec {\n  /** Stable identifier — used as `<source name=\"\">` and telemetry key. */\n  readonly id: string;\n  /** Priority for merge (lower = earlier in prompt). */\n  readonly priority: number;\n  /** Filename (cwd-only/git-root-walk) or glob (globbed). */\n  readonly pattern: string;\n  readonly scope: DiscoveryScope;\n  readonly parser: DiscoveryParser;\n  /** Whether to follow `@path` import directives (CLAUDE.md / GEMINI.md). */\n  readonly followImports: boolean;\n}\n\n/**\n * The context files theokit looks for out of the box, in the order they are concatenated.\n *\n * Two things follow from the ordering. `AGENTS.md` comes first at priority 10 and `THEO.md` last,\n * so theokit-specific instruction wins over the vendor-neutral file on conflict. And the array is\n * consumed in the order written — the runner does not re-sort it — so a caller passing its own\n * array is responsible for keeping `priority` and array position consistent.\n *\n * `CLAUDE.md` and `GEMINI.md` are the only two entries with `followImports: true`, which means\n * they are the only files whose `@path` directives pull other files into the prompt. Those\n * imports cannot escape the import root.\n *\n * Frozen only by type: `ReadonlyArray` is a compile-time constraint, and the array and its\n * elements are not deep-frozen at runtime. Build a new array rather than mutating this one.\n *\n * @public — re-exported from `@theokit/sdk/context`, and therefore under semver.\n */\nexport const DEFAULT_DISCOVERY_SPECS: ReadonlyArray<DiscoverySpec> = [\n  {\n    id: \"AGENTS.md\",\n    pattern: \"AGENTS.md\",\n    scope: \"git-root-walk\",\n    parser: \"plain-markdown\",\n    followImports: false,\n    priority: 10,\n  },\n  {\n    id: \"GEMINI.md\",\n    pattern: \"GEMINI.md\",\n    scope: \"git-root-walk\",\n    parser: \"plain-markdown\",\n    followImports: true,\n    priority: 20,\n  },\n  {\n    id: \"CLAUDE.md\",\n    pattern: \"CLAUDE.md\",\n    scope: \"git-root-walk\",\n    parser: \"plain-markdown\",\n    followImports: true,\n    priority: 30,\n  },\n  {\n    id: \"cursor-rules\",\n    pattern: \".cursor/rules/*.mdc\",\n    scope: \"globbed\",\n    parser: \"mdc\",\n    followImports: false,\n    priority: 40,\n  },\n  {\n    id: \"theokit-rules\",\n    pattern: \".theokit/rules/*.md\",\n    scope: \"globbed\",\n    parser: \"rules-frontmatter\",\n    followImports: false,\n    priority: 45,\n  },\n  {\n    // Rules written for the Claude Code CLI. Measured 2026-08-26 over this repository's 32 rule\n    // files: none carries frontmatter, and `rules-frontmatter` already reads a file without it as\n    // `alwaysApply: true` — the format needed nothing, only a spec pointing at the directory.\n    //\n    // 47, not 46. Specs sort ascending and a context budget drops the tail first, so it must land\n    // AFTER `.theokit/rules` (45) — the explicit namespace should survive a squeeze the borrowed one\n    // does not. It must also leave a slot on BOTH sides: B-127 makes these numbers a public contract\n    // precisely so a consumer can place its own source between two defaults, and 46 would have left\n    // no room between 45 and itself. 47 keeps 46 free below and 48–49 free above.\n    //\n    // The reckoning B-127's docblock asks for: no published priority MOVES, so a consumer that chose\n    // 46, 48 or 49 is unaffected. A consumer that had chosen 47 now collides — that is the cost of\n    // an eighth default, paid once and recorded here rather than discovered later.\n    id: \"claude-rules\",\n    pattern: \".claude/rules/*.md\",\n    scope: \"globbed\",\n    parser: \"rules-frontmatter\",\n    followImports: false,\n    priority: 47,\n  },\n  {\n    id: \"theokit-context\",\n    pattern: \".theokit/context/*.md\",\n    scope: \"globbed\",\n    parser: \"frontmatter-zod\",\n    followImports: false,\n    priority: 50,\n  },\n  {\n    id: \"THEO.md\",\n    pattern: \".theokit/THEO.md\",\n    scope: \"cwd-only\",\n    parser: \"plain-markdown\",\n    followImports: false,\n    priority: 60,\n  },\n];\n\nconst SAFE_FILENAME = /^[a-zA-Z0-9_.\\-/*]+$/;\nconst TRAVERSAL_RE = /(^|\\/)\\.\\.(\\/|$)/;\n\n/**\n * Reject patterns that contain path traversal (`..`) or non-allowed\n * characters (D81 parity, EC-4).\n *\n * @internal\n */\nexport function isSafePattern(pattern: string): boolean {\n  if (typeof pattern !== \"string\" || pattern.length === 0) return false;\n  if (TRAVERSAL_RE.test(pattern)) return false;\n  if (isAbsolute(pattern)) return false;\n  return SAFE_FILENAME.test(pattern);\n}\n\n/**\n * Walk upward from `cwd` looking for the closest directory containing\n * a `.git` entry (file OR directory — worktrees use a `.git` FILE,\n * EC-N). Returns the absolute path of that directory, or `undefined`\n * when no git root exists at or above `cwd`.\n *\n * @internal\n */\nexport function findGitRoot(cwd: string): string | undefined {\n  if (typeof cwd !== \"string\" || cwd.length === 0) return undefined;\n  let current = resolve(cwd);\n  // Guard against infinite loops on weird filesystems.\n  for (let i = 0; i < 64; i += 1) {\n    if (existsSync(join(current, \".git\"))) return current;\n    const parent = dirname(current);\n    if (parent === current) return undefined;\n    current = parent;\n  }\n  return undefined;\n}\n\n/**\n * Walk `cwd` upward to `stopDir` (inclusive) collecting every existing\n * occurrence of `filename`. Returns absolute, realpath-deduped paths in\n * nearest-first order (innermost dir first).\n *\n * No `.gitignore` parsing (EC-A). Realpath collapses symlink chains\n * pointing to the same physical file (EC-F). Filesystem races (file\n * deleted mid-walk) are skipped silently (EC-5).\n *\n * @internal\n */\n// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: walk-up loop combines validation + realpath dedup + FS-race handling + stopDir guard in a single bounded loop; splitting fragments the dedup invariant.\nexport function walkUpForFile(\n  cwd: string,\n  filename: string,\n  stopDir: string | undefined,\n): string[] {\n  if (!isSafePattern(filename)) {\n    return [];\n  }\n  const start = resolve(cwd);\n  const stop = stopDir !== undefined ? resolve(stopDir) : undefined;\n  const found: string[] = [];\n  const seenReal = new Set<string>();\n  let current = start;\n  // 64-level depth cap.\n  for (let i = 0; i < 64; i += 1) {\n    const candidate = join(current, filename);\n    if (existsSync(candidate)) {\n      let real: string;\n      try {\n        real = realpathSync(candidate);\n      } catch {\n        // FS race (deleted mid-walk) — skip.\n        real = candidate;\n      }\n      if (!seenReal.has(real)) {\n        seenReal.add(real);\n        found.push(real);\n      }\n    }\n    if (stop !== undefined && current === stop) break;\n    const parent = dirname(current);\n    if (parent === current) break;\n    current = parent;\n  }\n  return found;\n}\n\n/**\n * Glob-style discovery under `cwd` (e.g. `.cursor/rules/*.mdc`, `.theokit/rules/**\\/*.md`).\n * Returns absolute, lex-sorted paths.\n *\n * `*` matches within one path segment and `**` spans any depth, including zero — so\n * `.theokit/rules/**\\/*.md` finds `rules/top.md` as well as `rules/deep/nested/inner.md`, while\n * `.theokit/rules/*.md` keeps its flat meaning and finds only the first. That distinction is the\n * compatibility contract: every existing spec uses a single `*`, and widening it would silently\n * start absorbing nested files nobody chose to expose.\n *\n * ## Why this used to be flat, and what changed (B-119)\n *\n * The previous implementation split the pattern at its LAST `/`, treated the prefix as a literal\n * directory and did one `readdir` — documented as \"nested directories deferred to v2\" (EC-R). The\n * deferral was deliberate; what made it a defect was measured from a consumer. TheoCode's own rule\n * loader descends recursively, so migrating it onto the `theokit-rules` spec would have silently\n * dropped every nested rule — on the path that decides whether a repository's hooks execute. And a\n * pattern written to say so, `.theokit/rules/**\\/*.md`, resolved its directory part to a literal\n * `**` and matched NOTHING, not even the top-level file it matched before the globstar was added.\n *\n * ## Why the stdlib rather than a walker\n *\n * `fs.promises.glob` (Node ≥ 22, and this package requires ≥ 22.12) implements exactly these\n * semantics, verified against a fixture before adoption: `**\\/*.md` returns all three depths,\n * `*.md` returns one, and it emits no experimental warning. Writing a recursive walker here would\n * have been a third implementation of matching inside one package — the same duplication that let\n * the enumerator and the compiler in `context-glob.ts` disagree in the first place. `globToRegex`\n * stays where it belongs: deciding whether a rule APPLIES to a set of paths, which is a different\n * question from which files exist.\n *\n * `isSafePattern` still runs first and is unchanged, so `..` is refused before any I/O.\n *\n * @internal\n */\nexport async function walkUpForGlob(cwd: string, pattern: string): Promise<string[]> {\n  if (!isSafePattern(pattern)) return [];\n  const found: string[] = [];\n  try {\n    for await (const entry of glob(pattern, { cwd })) {\n      found.push(resolve(cwd, entry));\n    }\n  } catch {\n    // A pattern whose directory does not exist is the ordinary case — most projects have no\n    // `.cursor/rules/`. Same outcome as matching nothing.\n    return [];\n  }\n  // Sorted, because discovery order becomes prompt order and must not vary with the filesystem.\n  //\n  // The comparator is explicit and deliberately NOT `localeCompare`, which is the usual suggestion\n  // for a bare `.sort()`. `localeCompare` orders by the machine's locale, so the same tree would\n  // assemble a different prompt on a differently-configured machine — trading one source of\n  // non-determinism for a subtler one. Code-unit ordering is what a bare `.sort()` already does for\n  // strings; writing it out states the intent and keeps the result machine-independent.\n  return found.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));\n}\n"]}

package/dist/{chunk-HJBMA5MB.cjs → chunk-WNTAPVU5.cjs}

@@ -1,10 +1,29 @@
 'use strict';
 
+var chunkAQO3NSRG_cjs = require('./chunk-AQO3NSRG.cjs');
 var chunkIWBGCBR6_cjs = require('./chunk-IWBGCBR6.cjs');
 var chunkK3FW2XZD_cjs = require('./chunk-K3FW2XZD.cjs');
+var chunkNUKRL3I6_cjs = require('./chunk-NUKRL3I6.cjs');
 var promises = require('fs/promises');
 var path = require('path');
 
+async function pluginBundleDirs(cwd) {
+  const dirs = [];
+  for (const root of chunkAQO3NSRG_cjs.pluginBundleRoots(cwd)) {
+    let entries;
+    try {
+      entries = await promises.readdir(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) dirs.push(path.join(root, entry.name));
+    }
+  }
+  return dirs;
+}
+
+// src/internal/runtime/skills/subagents-loader.ts
 async function loadSubagents(cwd, settingSourcesIncludeProject, inline) {
   const result = {};
   if (settingSourcesIncludeProject) {
@@ -21,17 +40,30 @@ async function loadSubagents(cwd, settingSourcesIncludeProject, inline) {
   return result;
 }
 async function readProjectSubagents(cwd) {
-  const root = path.join(cwd, ".theokit", "agents");
-  const entries = await chunkIWBGCBR6_cjs.readWorkspaceDir(root, "subagents_read_error", "subagents directory");
   const subagents = {};
+  for (const configRoot of chunkAQO3NSRG_cjs.projectConfigRoots(cwd)) {
+    await readSubagentsFrom(path.join(configRoot, "agents"), subagents);
+  }
+  for (const bundle of await pluginBundleDirs(cwd)) {
+    await readSubagentsFrom(path.join(bundle, "agents"), subagents);
+  }
+  return subagents;
+}
+async function readSubagentsFrom(root, subagents) {
+  const entries = await chunkIWBGCBR6_cjs.readWorkspaceDir(root, "subagents_read_error", "subagents directory");
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
     const path$1 = path.join(root, entry.name);
     const raw = await promises.readFile(path$1, "utf8");
+    if (!hasFrontmatter(raw)) {
+      chunkNUKRL3I6_cjs.diag(`[theokit-sdk] ${entry.name} has no frontmatter \u2014 not an agent declaration, skipping`);
+      continue;
+    }
     const definition = parseSubagentMarkdown(raw, entry.name);
-    subagents[definition.name] = definition.definition;
+    if (subagents[definition.name] === void 0) {
+      subagents[definition.name] = definition.definition;
+    }
   }
-  return subagents;
 }
 var ACCEPTED_FIELDS = /* @__PURE__ */ new Set([
   "name",
@@ -42,6 +74,10 @@ var ACCEPTED_FIELDS = /* @__PURE__ */ new Set([
   "mcp",
   "sandbox"
 ]);
+var INERT_CLAUDE_CODE_FIELDS = /* @__PURE__ */ new Set([
+  /** The CLI's label colour for the agent. Presentation only. */
+  "color"
+]);
 function parseSubagentMarkdown(raw, filename) {
   const { frontmatter, body } = splitFrontmatter(raw, filename);
   const fields = parseFrontmatterFields(frontmatter);
@@ -62,6 +98,7 @@ function parseSubagentMarkdown(raw, filename) {
 }
 function rejectUnknownFields(fields, filename) {
   for (const key of Object.keys(fields)) {
+    if (INERT_CLAUDE_CODE_FIELDS.has(key)) continue;
     if (!ACCEPTED_FIELDS.has(key)) {
       throw new chunkK3FW2XZD_cjs.ConfigurationError(
         `Subagent ${filename}: unknown frontmatter field "${key}" (accepted: ${[...ACCEPTED_FIELDS].join(", ")})`,
@@ -113,6 +150,9 @@ function toStringList(v) {
   }
   return [];
 }
+function hasFrontmatter(raw) {
+  return /^---\s*\n/.test(raw);
+}
 function splitFrontmatter(raw, filename) {
   const match = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/.exec(raw);
   if (match === null) {
@@ -127,5 +167,6 @@ function parseFrontmatterFields(frontmatter) {
 }
 
 exports.loadSubagents = loadSubagents;
-//# sourceMappingURL=chunk-HJBMA5MB.cjs.map
-//# sourceMappingURL=chunk-HJBMA5MB.cjs.map
+exports.pluginBundleDirs = pluginBundleDirs;
+//# sourceMappingURL=chunk-WNTAPVU5.cjs.map
+//# sourceMappingURL=chunk-WNTAPVU5.cjs.map

package/dist/chunk-WNTAPVU5.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/runtime/plugins/plugin-bundles.ts","../src/internal/runtime/skills/subagents-loader.ts"],"names":["pluginBundleRoots","readdir","join","projectConfigRoots","readWorkspaceDir","path","readFile","diag","ConfigurationError","parseSimpleYaml"],"mappings":"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","file":"chunk-WNTAPVU5.cjs","sourcesContent":["/**\n * Locating the plugin bundles a project carries.\n *\n * Shared by the skills and subagents loaders, which both need the same answer to \"which folders in\n * this project are plugins\" and would otherwise each grow their own copy of the directory walk.\n *\n * @internal\n */\n\nimport type { Dirent } from \"node:fs\";\nimport { readdir } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { pluginBundleRoots } from \"../../persistence/paths.js\";\n\n/**\n * Every plugin folder under the project's plugin roots.\n *\n * Returns the FOLDERS, not their contents — what a bundle contributes (`skills/`, `agents/`) is the\n * caller's business, and a loader that also knew the layout would have to change whenever the other\n * one did.\n *\n * A missing root is not an error: most projects carry no plugins, and treating their absence as a\n * failure would make \"none installed\" indistinguishable from \"the directory could not be read\".\n */\nexport async function pluginBundleDirs(cwd: string): Promise<string[]> {\n  const dirs: string[] = [];\n  for (const root of pluginBundleRoots(cwd)) {\n    let entries: Dirent[];\n    try {\n      entries = await readdir(root, { withFileTypes: true });\n    } catch {\n      continue;\n    }\n    for (const entry of entries) {\n      if (entry.isDirectory()) dirs.push(join(root, entry.name));\n    }\n  }\n  return dirs;\n}\n","import { readFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\n\nimport { ConfigurationError } from \"../../../errors.js\";\nimport type { AgentDefinition } from \"../../../types/agent.js\";\nimport type { ModelSelection } from \"../../../types/agent-prims.js\";\nimport { diag } from \"../../diagnostics.js\";\nimport { projectConfigRoots } from \"../../persistence/paths.js\";\nimport { readWorkspaceDir } from \"../config/workspace-dir.js\";\nimport { type FrontmatterValue, parseSimpleYaml } from \"../context/yaml-frontmatter.js\";\nimport { pluginBundleDirs } from \"../plugins/plugin-bundles.js\";\n\n/**\n * Load file-based subagents from `.theokit/agents/*.md` and merge with\n * inline definitions. Inline overrides file-based on name conflict.\n *\n * Each markdown file has YAML frontmatter (description + optional model)\n * and a body that becomes the subagent prompt.\n *\n * @internal\n */\nexport async function loadSubagents(\n  cwd: string,\n  settingSourcesIncludeProject: boolean,\n  inline: Record<string, AgentDefinition> | undefined,\n): Promise<Record<string, AgentDefinition>> {\n  const result: Record<string, AgentDefinition> = {};\n  if (settingSourcesIncludeProject) {\n    const projectAgents = await readProjectSubagents(cwd);\n    for (const [name, definition] of Object.entries(projectAgents)) {\n      result[name] = definition;\n    }\n  }\n  if (inline !== undefined) {\n    for (const [name, definition] of Object.entries(inline)) {\n      result[name] = definition;\n    }\n  }\n  return result;\n}\n\n/**\n * Read agent declarations from every project config root (`.theokit`, then `.claude`).\n *\n * FIRST occurrence of a name wins, which is what makes `projectConfigRoots`' order a contract rather\n * than a detail: a project declaring the same agent in both means the explicit namespace.\n */\nasync function readProjectSubagents(cwd: string): Promise<Record<string, AgentDefinition>> {\n  const subagents: Record<string, AgentDefinition> = {};\n  for (const configRoot of projectConfigRoots(cwd)) {\n    await readSubagentsFrom(join(configRoot, \"agents\"), subagents);\n  }\n  // A Claude Code plugin is a BUNDLE, and its `agents/` is what it exists to contribute. Read after\n  // the project's own, so a project can shadow an agent a plugin ships without editing the plugin.\n  for (const bundle of await pluginBundleDirs(cwd)) {\n    await readSubagentsFrom(join(bundle, \"agents\"), subagents);\n  }\n  return subagents;\n}\n\nasync function readSubagentsFrom(\n  root: string,\n  subagents: Record<string, AgentDefinition>,\n): Promise<void> {\n  const entries = await readWorkspaceDir(root, \"subagents_read_error\", \"subagents directory\");\n  for (const entry of entries) {\n    if (!entry.isFile() || !entry.name.endsWith(\".md\")) continue;\n    const path = join(root, entry.name);\n    const raw = await readFile(path, \"utf8\");\n    // A markdown file with NO frontmatter is not an agent declaration — a directory of agents\n    // written for the Claude Code CLI conventionally carries documentation beside them, and\n    // `.claude/agents/README.md` exists in this repository. Throwing on it made ONE such file stop\n    // every agent in the directory from loading.\n    //\n    // Skipped with a warn rather than in silence, and ONLY for the no-frontmatter case: a file that\n    // HAS frontmatter and gets it wrong is a broken agent and still fails loudly, which is what\n    // keeps a typo'd `sandbox` from returning as a silent gate through this door.\n    if (!hasFrontmatter(raw)) {\n      diag(`[theokit-sdk] ${entry.name} has no frontmatter — not an agent declaration, skipping`);\n      continue;\n    }\n    const definition = parseSubagentMarkdown(raw, entry.name);\n    if (subagents[definition.name] === undefined) {\n      subagents[definition.name] = definition.definition;\n    }\n  }\n}\n\n// The frontmatter keys a disk subagent may declare. Any other key is a typed load\n// error rather than a silent drop — a dropped `sandbox` an operator wrote believing\n// it confines the child is exactly the silent-gate failure class this guards against.\nconst ACCEPTED_FIELDS = new Set([\n  \"name\",\n  \"description\",\n  \"model\",\n  \"tools\",\n  \"reasoning_effort\",\n  \"mcp\",\n  \"sandbox\",\n]);\n\n// Fields the Claude Code CLI writes that carry NO behaviour for this runtime. Accepted and ignored,\n// so an agent authored for the CLI loads here unchanged — measured 2026-08-26 across the 59 agent\n// files on one machine, where `color` appeared in 38 of them and made every one of those a\n// `subagent_unknown_field` load error.\n//\n// Named explicitly instead of loosening the check above, because that check's reason is sound: a\n// dropped `sandbox` an operator wrote believing it confines the child is a silent gate. A field that\n// COULD change behaviour must still fail loudly. This set is the difference between \"we know this\n// one and it does nothing\" and \"we have never heard of this\" — two facts a bare allow-everything\n// would collapse into one.\n//\n// Anything added here needs the same justification: inert for THIS runtime, not merely unfamiliar.\nconst INERT_CLAUDE_CODE_FIELDS = new Set([\n  /** The CLI's label colour for the agent. Presentation only. */\n  \"color\",\n]);\n\nfunction parseSubagentMarkdown(\n  raw: string,\n  filename: string,\n): { name: string; definition: AgentDefinition } {\n  const { frontmatter, body } = splitFrontmatter(raw, filename);\n  const fields = parseFrontmatterFields(frontmatter);\n  rejectUnknownFields(fields, filename);\n  rejectMcp(fields, filename);\n\n  const definition: AgentDefinition = {\n    description: asString(fields.description) ?? \"\",\n    prompt: body,\n  };\n  const model = resolveModel(fields, filename);\n  if (model !== undefined) definition.model = model;\n  const tools = toStringList(fields.tools);\n  if (tools.length > 0) definition.tools = tools;\n  const sandbox = resolveSandbox(fields, filename);\n  if (sandbox !== undefined) definition.sandbox = sandbox;\n\n  const name = asString(fields.name) ?? filename.replace(/\\.md$/, \"\");\n  return { name, definition };\n}\n\nfunction rejectUnknownFields(\n  fields: Record<string, FrontmatterValue | undefined>,\n  filename: string,\n): void {\n  for (const key of Object.keys(fields)) {\n    if (INERT_CLAUDE_CODE_FIELDS.has(key)) continue;\n    if (!ACCEPTED_FIELDS.has(key)) {\n      throw new ConfigurationError(\n        `Subagent ${filename}: unknown frontmatter field \"${key}\" (accepted: ${[...ACCEPTED_FIELDS].join(\", \")})`,\n        { code: \"subagent_unknown_field\" },\n      );\n    }\n  }\n}\n\n// mcp: a known field, but not yet honored on the LOCAL delegation path. The frontmatter YAML can only\n// express server NAMES (parseSimpleYaml has no nested-object support), while a child's `Agent.create`\n// needs `mcpServers` as a Record<name, config>; resolving names→config per-subagent in local delegation\n// is its own follow-up. Rather than silently drop it (the M26/M32 silent-gate class), it is a typed load\n// error that names the field and points at the alternative.\nfunction rejectMcp(fields: Record<string, FrontmatterValue | undefined>, filename: string): void {\n  if (fields.mcp !== undefined) {\n    throw new ConfigurationError(\n      `Subagent ${filename}: per-subagent \"mcp\" is not yet supported on the local delegation path; declare MCP servers in .theokit/mcp.json (or the parent) instead`,\n      { code: \"subagent_mcp_unsupported_local\" },\n    );\n  }\n}\n\n// model + reasoning_effort — effort rides inside `model.params[thinking]`, so it requires a concrete\n// model id to attach to (a child inheriting the parent's model cannot carry the parent's provider-\n// specific effort param safely).\nfunction resolveModel(\n  fields: Record<string, FrontmatterValue | undefined>,\n  filename: string,\n): ModelSelection | \"inherit\" | undefined {\n  const modelId = asString(fields.model);\n  const effort = asString(fields.reasoning_effort);\n  // reasoning_effort rides in model.params[thinking], so it needs a CONCRETE model id to attach to.\n  // Neither an absent model NOR `model: inherit` can carry it (the inherited id is unknown at load), so\n  // both are typed errors rather than a silently-dropped effort — the silent-gate class this guards.\n  if (effort !== undefined && (modelId === undefined || modelId === \"inherit\")) {\n    throw new ConfigurationError(\n      `Subagent ${filename}: reasoning_effort requires a concrete model (effort is a model parameter; an absent model or \"inherit\" cannot carry it)`,\n      { code: \"subagent_reasoning_effort_without_model\" },\n    );\n  }\n  if (modelId === undefined) return undefined;\n  if (modelId === \"inherit\") return \"inherit\";\n  return effort !== undefined\n    ? { id: modelId, params: [{ id: \"thinking\", value: effort }] }\n    : { id: modelId };\n}\n\n// sandbox: boolean only. A granular mode string (read-only/…) is unsupported by the SDK runtime and is\n// a typed error rather than a silent coercion to a boolean.\nfunction resolveSandbox(\n  fields: Record<string, FrontmatterValue | undefined>,\n  filename: string,\n): boolean | undefined {\n  if (fields.sandbox === undefined) return undefined;\n  if (typeof fields.sandbox !== \"boolean\") {\n    throw new ConfigurationError(\n      `Subagent ${filename}: sandbox must be a boolean (got \"${String(fields.sandbox)}\"); granular sandbox modes are not supported by the runtime`,\n      { code: \"subagent_sandbox_not_boolean\" },\n    );\n  }\n  return fields.sandbox;\n}\n\nfunction asString(v: FrontmatterValue | undefined): string | undefined {\n  if (typeof v !== \"string\") return undefined;\n  // parseSimpleYaml does not strip quotes (documented), and `model`/`reasoning_effort` are fields users\n  // habitually quote (`model: \"openai/gpt-4o\"`). Strip a single matching surrounding quote pair so a\n  // quoted id/effort does not slip past validation and fail only at the provider.\n  const m = /^([\"'])(.*)\\1$/.exec(v);\n  return m ? m[2] : v;\n}\n\n/** Accept a YAML list (`string[]`) or a comma/space-separated scalar; trim + drop empties. */\nfunction toStringList(v: FrontmatterValue | undefined): string[] {\n  if (Array.isArray(v)) return v.map((t) => t.trim()).filter((t) => t.length > 0);\n  if (typeof v === \"string\") {\n    return v\n      .split(/[\\s,]+/)\n      .map((t) => t.trim())\n      .filter((t) => t.length > 0);\n  }\n  return [];\n}\n\n/** Does this file open with a frontmatter block at all? Its ABSENCE means \"not an agent\". */\nfunction hasFrontmatter(raw: string): boolean {\n  return /^---\\s*\\n/.test(raw);\n}\n\nfunction splitFrontmatter(raw: string, filename: string): { frontmatter: string; body: string } {\n  const match = /^---\\s*\\n([\\s\\S]*?)\\n---\\s*\\n([\\s\\S]*)$/.exec(raw);\n  if (match === null) {\n    throw new ConfigurationError(`Subagent ${filename} is missing frontmatter`, {\n      code: \"subagent_missing_frontmatter\",\n    });\n  }\n  return { frontmatter: match[1] ?? \"\", body: (match[2] ?? \"\").trim() };\n}\n\nfunction parseFrontmatterFields(frontmatter: string): Record<string, FrontmatterValue | undefined> {\n  // Preserve the rich YAML value types (boolean/number/string[]): `sandbox: true` and\n  // `mcp: [a, b]` are meaningful here, so narrowing everything to string (as the\n  // pre-M33 loader did) would drop them. Per-field validation happens in parseSubagentMarkdown.\n  return parseSimpleYaml(frontmatter);\n}\n"]}

package/dist/{chunk-G6EEYRDD.js → chunk-ZA255A62.js}

@@ -1,6 +1,7 @@
 import { LruEmbeddingCache } from './chunk-H73MEMQB.js';
 import { splitFrontmatter, parseSimpleYaml } from './chunk-KVNWIAO4.js';
 import { sanitizeIdentifier, safePathJoin, safeFilenameForId } from './chunk-QARJGQSA.js';
+import { encodeProjectDir } from './chunk-FKMUFNQE.js';
 import { openSqliteResilient, sanitizeFts5Query } from './chunk-CQ2TQ32Y.js';
 import { withCwdMutex } from './chunk-Q5EWJPRY.js';
 import { replaceFileAtomic } from './chunk-VF7EWVDG.js';
@@ -11,6 +12,7 @@ import { readdir, readFile, mkdir, stat } from 'fs/promises';
 import { join, resolve, relative } from 'path';
 import { mkdirSync } from 'fs';
 import { createRequire } from 'module';
+import { homedir } from 'os';
 
 // src/internal/memory/escape-like-pattern.ts
 function escapeLikePattern(query) {
@@ -363,23 +365,37 @@ var FACTS_HEADING = "## Facts";
 function memoryDir(cwd) {
   return join(cwd, ".theokit", "memory");
 }
+function memoryWriteDir(cwd, sessionDir) {
+  if (sessionDir === void 0 || sessionDir.trim().length === 0) return memoryDir(cwd);
+  return join(sessionDir, "projects", encodeProjectDir(cwd), "memory");
+}
+function claudeProjectMemoryDir(cwd) {
+  const home = process.env.CLAUDE_CONFIG_DIR?.trim();
+  const root = home !== void 0 && home.length > 0 ? home : join(homedir(), ".claude");
+  return join(root, "projects", encodeProjectDir(cwd), "memory");
+}
 function memoryMdPath(cwd) {
   return join(memoryDir(cwd), "MEMORY.md");
 }
 function notesDir(cwd) {
   return join(memoryDir(cwd), "notes");
 }
-async function readFactsFromMarkdown(cwd) {
-  let entries;
-  try {
-    entries = await readdir(memoryDir(cwd));
-  } catch {
-    return [];
-  }
+async function readFactsFromMarkdown(cwd, sessionDir) {
   const facts = [];
-  for (const entry of entries.sort()) {
-    const fact = await readMemoryFileAt(cwd, entry);
-    if (fact !== void 0) facts.push(fact);
+  const roots = [
+    .../* @__PURE__ */ new Set([memoryDir(cwd), memoryWriteDir(cwd, sessionDir), claudeProjectMemoryDir(cwd)])
+  ];
+  for (const dir of roots) {
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries.sort()) {
+      const fact = await readMemoryFileIn(dir, entry);
+      if (fact !== void 0) facts.push(fact);
+    }
   }
   try {
     facts.push(...parseFactsSection(await readFile(memoryMdPath(cwd), "utf8")));
@@ -387,24 +403,25 @@ async function readFactsFromMarkdown(cwd) {
   }
   return facts;
 }
-async function readMemoryFileAt(cwd, entry) {
+async function readMemoryFileIn(dir, entry) {
   if (!entry.endsWith(".md") || entry === "MEMORY.md") return void 0;
   let raw;
   try {
-    raw = await readFile(join(memoryDir(cwd), entry), "utf8");
+    raw = await readFile(join(dir, entry), "utf8");
   } catch {
     return void 0;
   }
   const parsed = parseMemoryFile(raw);
   if (parsed === void 0) return void 0;
+  const body = parsed.body.trim();
   return {
-    text: parsed.description,
+    text: body.length > 0 ? body : parsed.description,
     ...parsed.kind !== void 0 ? { kind: parsed.kind } : {},
     ...parsed.modified !== void 0 ? { modified: parsed.modified } : {}
   };
 }
-function appendFactToMarkdown(cwd, fact) {
-  return withCwdMutex(memoryDir(cwd), async () => {
+function appendFactToMarkdown(cwd, fact, targetDir = memoryDir(cwd)) {
+  return withCwdMutex(targetDir, async () => {
     if (fact.kind !== void 0 && !MEMORY_KINDS.includes(fact.kind)) {
       throw new ConfigurationError(
         `Unknown memory fact kind "${fact.kind}". Expected one of: ${MEMORY_KINDS.join(", ")}.`,
@@ -413,9 +430,9 @@ function appendFactToMarkdown(cwd, fact) {
     }
     const text = redactSecrets(fact.text);
     const name = slugForFact(text);
-    await mkdir(memoryDir(cwd), { recursive: true });
+    await mkdir(targetDir, { recursive: true });
     await replaceFileAtomic(
-      join(memoryDir(cwd), `${name}.md`),
+      join(targetDir, `${name}.md`),
       renderMemoryFile({
         name,
         description: text,
@@ -424,13 +441,13 @@ function appendFactToMarkdown(cwd, fact) {
         body: text
       })
     );
-    await replaceFileAtomic(memoryMdPath(cwd), await nextIndex(cwd, text, name));
+    await replaceFileAtomic(join(targetDir, "MEMORY.md"), await nextIndex(targetDir, text, name));
   });
 }
-async function nextIndex(cwd, text, name) {
+async function nextIndex(dir, text, name) {
   let existing = "";
   try {
-    existing = await readFile(memoryMdPath(cwd), "utf8");
+    existing = await readFile(join(dir, "MEMORY.md"), "utf8");
   } catch {
     existing = "";
   }
@@ -451,13 +468,13 @@ function parseFactsSection(raw) {
   const block = nextHeading === -1 ? tail : tail.slice(0, nextHeading);
   return block.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("- ")).map((line) => line.slice(2).trim()).filter((body) => !INDEX_ENTRY.test(body)).map((body) => ({ text: body }));
 }
-async function readFacts(cwd, config) {
+async function readFacts(cwd, config, memoryHome) {
   if (!config.enabled) return [];
-  return readFactsFromMarkdown(cwd);
+  return readFactsFromMarkdown(cwd, memoryHome);
 }
-async function appendFact(cwd, config, fact) {
+async function appendFact(cwd, config, fact, memoryHome) {
   if (!config.enabled) return;
-  await appendFactToMarkdown(cwd, fact);
+  await appendFactToMarkdown(cwd, fact, memoryWriteDir(cwd, memoryHome));
 }
 var MAX_TURN_CHARS = 2e3;
 function sessionsDir(cwd) {
@@ -1045,5 +1062,5 @@ var IndexManager = class _IndexManager {
 };
 
 export { IndexManager, LanceIndex, MEMORY_KINDS, appendFact, appendFactToMarkdown, defaultIndexPath, lanceStoragePath, legacyMemoryJsonPath, memoryDir, memoryMdPath, openMemoryDb, readFacts, readFactsFromMarkdown, writeSessionSummary };
-//# sourceMappingURL=chunk-G6EEYRDD.js.map
-//# sourceMappingURL=chunk-G6EEYRDD.js.map
+//# sourceMappingURL=chunk-ZA255A62.js.map
+//# sourceMappingURL=chunk-ZA255A62.js.map