@fro.bot/systematic 3.4.0 → 3.5.0

package/dist/{index-0vm17gwv.js → index-1mb4baxr.js}

@@ -16206,6 +16206,58 @@ var CategoryOverlaySchema = exports_external.object({
   description: "Per-category configuration overlay (same fields as agent minus disable)",
   examples: [{ model: "anthropic/claude-opus-4-7", temperature: 0.1 }]
 });
+var piSubagentsThinkingSchema = exports_external.enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]).meta({
+  description: "pi-subagents reasoning effort level for exported persona frontmatter",
+  examples: ["off", "medium", "high"]
+});
+var piSubagentsMaxTurnsSchema = exports_external.number().int().nonnegative().meta({
+  description: "pi-subagents maximum turns for a delegated persona (0 = unlimited)",
+  examples: [0, 10, 25]
+});
+var piSubagentsToolsSchema = exports_external.string().min(1).meta({
+  description: "pi-subagents comma-selector tool string (built-ins, */all/none, or extension selectors)",
+  examples: ["*", "read,grep,glob", "none"]
+});
+var piSubagentsSkillsSchema = exports_external.union([exports_external.literal(true), exports_external.string().min(1)]).meta({
+  description: "pi-subagents skills selector: true (all) or a comma-separated list of skill names",
+  examples: [true, "ce:plan,ce:review"]
+});
+var PiSubagentsAgentOverlaySchema = exports_external.object({
+  thinking: trustProtected(piSubagentsThinkingSchema).optional(),
+  max_turns: trustAny(piSubagentsMaxTurnsSchema).optional(),
+  tools: trustProtected(piSubagentsToolsSchema).optional(),
+  skills: trustProtected(piSubagentsSkillsSchema).optional()
+}).strict().meta({
+  description: "Per-agent pi-subagents export overlay (Pi-native fields only; no model)",
+  examples: [{ thinking: "high", max_turns: 10 }]
+});
+var PiSubagentsCategoryOverlaySchema = PiSubagentsAgentOverlaySchema.meta({
+  description: "Per-category pi-subagents export overlay (Pi-native fields only; no model)",
+  examples: [{ thinking: "medium" }]
+});
+var PiSubagentsSchema = exports_external.object({
+  categories: exports_external.record(exports_external.string(), PiSubagentsCategoryOverlaySchema).default({}).meta({
+    description: "Per-category pi-subagents export overlays keyed by category name",
+    examples: [{ research: { thinking: "high" } }, {}]
+  }),
+  agents: exports_external.record(exports_external.string(), PiSubagentsAgentOverlaySchema).default({}).meta({
+    description: "Per-agent pi-subagents export overlays keyed by bundled agent name",
+    examples: [{ "repo-research-analyst": { max_turns: 10 } }, {}]
+  })
+}).strict().default({ categories: {}, agents: {} }).meta({
+  description: "Pi-native pi-subagents export field overlays (thinking, max_turns, tools, skills). Category values apply first; per-agent values override. No model field \u2014 model stays in the categories/agents overlay.",
+  examples: [
+    {
+      categories: { research: { thinking: "high" } },
+      agents: { "repo-research-analyst": { max_turns: 10 } }
+    }
+  ]
+});
+var PI_SUBAGENTS_PROTECTED_FIELDS = [
+  "thinking",
+  "tools",
+  "skills"
+];
 var BootstrapSchema = exports_external.object({
   enabled: exports_external.boolean().default(true).meta({
     description: "Enable bootstrap prompt injection into every conversation",
@@ -16276,6 +16328,7 @@ function createSystematicConfigSchema(opts) {
       ]
     }),
     workflow_guard: WorkflowGuardSchema,
+    pi_subagents: PiSubagentsSchema,
     skills_as_commands: exports_external.boolean().default(true).meta({
       description: "Register skills discovered from user/project skill directories (OpenCode config and other agent-harness-standard locations) as slash commands. Default true.",
       examples: [true, false]
@@ -16315,6 +16368,7 @@ var DEFAULT_CONFIG = {
   },
   agents: {},
   categories: {},
+  pi_subagents: { categories: {}, agents: {} },
   skills_as_commands: true
 };
 var SECURITY_OVERLAY_FIELDS2 = new Set(SECURITY_OVERLAY_FIELDS);
@@ -16473,16 +16527,18 @@ function mergeArraysUnique(arr1, arr2) {
       set2.add(item);
   return Array.from(set2);
 }
-function loadConfig(projectDir) {
-  return loadConfigWithSources(projectDir).config;
+function loadConfig(projectDir, options) {
+  return loadConfigWithSources(projectDir, options).config;
 }
-function loadConfigWithSources(projectDir) {
+function loadConfigWithSources(projectDir, options) {
+  const includeProject = options?.includeProject ?? true;
   const paths = getConfigPaths(projectDir);
   const userSource = loadConfigSource(paths.userConfig, "user");
-  const projectSource = loadConfigSource(paths.projectConfig, "project");
+  const projectSource = includeProject ? loadConfigSource(paths.projectConfig, "project") : null;
   const customSource = paths.customConfig ? loadConfigSource(paths.customConfig, "custom") : null;
   const sources = [userSource, projectSource, customSource].filter((source) => source !== null);
   const mergedOverlays = mergeOverlaySources(sources);
+  const mergedPiSubagentsOverlays = mergePiSubagentsOverlaySources(sources);
   const droppedCategories = Object.keys(mergedOverlays.categories).filter((name) => REMOVED_AGENT_CATEGORIES_SET.has(name));
   const warned = new Set;
   warnDroppedNames(droppedCategories, "categories", warned, "v3.0.0");
@@ -16511,6 +16567,10 @@ function loadConfigWithSources(projectDir) {
     },
     agents: overlayValues(overlays.agents),
     categories: overlayValues(overlays.categories),
+    pi_subagents: {
+      categories: overlayValues(mergedPiSubagentsOverlays.categories),
+      agents: overlayValues(mergedPiSubagentsOverlays.agents)
+    },
     skills_as_commands: customConfig?.skills_as_commands ?? projectConfig?.skills_as_commands ?? userConfig?.skills_as_commands ?? DEFAULT_CONFIG.skills_as_commands
   };
   const droppedSkills = computeDroppedNames(result.disabled_skills, CURRENT_SKILL_NAMES_SET);
@@ -16577,6 +16637,57 @@ function preserveSecurityFields(previous, next) {
   }
   return result;
 }
+var PI_SUBAGENTS_PROTECTED_FIELD_SET = new Set(PI_SUBAGENTS_PROTECTED_FIELDS);
+function mergePiSubagentsOverlaySources(sources) {
+  const result = {
+    agents: {},
+    categories: {}
+  };
+  for (const source of sources) {
+    mergePiSubagentsOverlayMap(result.agents, source, "agents");
+    mergePiSubagentsOverlayMap(result.categories, source, "categories");
+  }
+  return result;
+}
+function stripPiSubagentsProtectedFields(value) {
+  const result = {};
+  for (const [field, fieldValue] of Object.entries(value)) {
+    if (PI_SUBAGENTS_PROTECTED_FIELD_SET.has(field))
+      continue;
+    result[field] = fieldValue;
+  }
+  return result;
+}
+function preservePiSubagentsProtectedFields(previous, next) {
+  const result = { ...next };
+  for (const field of PI_SUBAGENTS_PROTECTED_FIELD_SET) {
+    if (Object.hasOwn(previous, field)) {
+      result[field] = previous[field];
+    }
+  }
+  return result;
+}
+function mergePiSubagentsOverlayMap(target, source, mapKey) {
+  const overlayMap = source.config.pi_subagents?.[mapKey];
+  if (overlayMap === undefined)
+    return;
+  if (!isRecord2(overlayMap)) {
+    throwInvalidOverlay(source.path, `pi_subagents.${mapKey}`);
+  }
+  for (const [key, rawValue] of Object.entries(overlayMap)) {
+    const keyPath = `pi_subagents.${mapKey}.${key}`;
+    if (!isRecord2(rawValue)) {
+      throwInvalidOverlay(source.path, keyPath);
+    }
+    const previous = target[key];
+    const value = source.trust === "project" ? preservePiSubagentsProtectedFields(previous?.value ?? {}, stripPiSubagentsProtectedFields(rawValue)) : rawValue;
+    target[key] = {
+      value,
+      sourcePath: source.path,
+      keyPath
+    };
+  }
+}
 function overlayValues(overlays) {
   const result = {};
   for (const [key, overlay] of Object.entries(overlays)) {

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   loadConfigWithSources,
   parseFrontmatter,
   walkDir
-} from "./index-0vm17gwv.js";
+} from "./index-1mb4baxr.js";
 
 // src/index.ts
 import { createHash as createHash5 } from "crypto";
@@ -2890,6 +2890,19 @@ function seedFromMarker(marker) {
     capabilityFlags: marker.capabilityFlags
   };
 }
+function registrationDigestFromMarker(marker) {
+  if (marker.kind === "mint")
+    return marker.envelope.registrationDigest;
+  return marker.registrationDigest;
+}
+function filterMarkersByRegistration(markers, ownRegistrationDigest) {
+  return markers.filter((input) => {
+    const validation = validateReceiptMarker(input);
+    if (validation.status !== "valid")
+      return true;
+    return registrationDigestFromMarker(validation.marker) === ownRegistrationDigest;
+  });
+}
 function extractReceiptReadbackSeed(inputs) {
   if (inputs.length === 0)
     return { status: "empty" };
@@ -10400,6 +10413,11 @@ var statusToolSchema = exports_external.object(statusToolShape).strict();
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function decodeSessionSaltBytes(hex) {
+  if (typeof hex !== "string" || hex.length !== 64 || !/^[0-9a-f]+$/.test(hex))
+    return;
+  return Uint8Array.from(Buffer.from(hex, "hex"));
+}
 function boundedString(value, maxLength) {
   return typeof value === "string" && value.length > 0 && value.length <= maxLength;
 }
@@ -10979,6 +10997,46 @@ function createSessionRuntime(options) {
   function seedAgrees(nextLedger, seed) {
     return nextLedger.metadata.registrationDigest === seed.registrationDigest && JSON.stringify(nextLedger.metadata.capabilityFlags) === JSON.stringify(["workflow-guard"]);
   }
+  function candidateSeedFromMarker(input) {
+    const validation = validateReceiptMarker(input);
+    if (validation.status !== "valid")
+      return;
+    const marker = validation.marker;
+    if (marker.kind === "mint") {
+      const salt = decodeSessionSaltBytes(marker.sessionSalt);
+      return salt ? { salt, digest: marker.envelope.registrationDigest } : undefined;
+    }
+    if (marker.kind === "control" && marker.control === "progression") {
+      const salt = decodeSessionSaltBytes(marker.sessionSalt);
+      return salt ? { salt, digest: marker.registrationDigest } : undefined;
+    }
+    return;
+  }
+  function candidateAgreesWithOwnIdentity(salt, digest2) {
+    try {
+      const probe = createReceiptLedger({
+        capabilityFlags: ["workflow-guard"],
+        registrationIdentity: options.registrationIdentity,
+        sessionSalt: salt
+      });
+      return probe.metadata.registrationDigest === digest2;
+    } catch {
+      return false;
+    }
+  }
+  function resolveOwnRegistrationDigest(markers) {
+    const seenDigests = new Set;
+    for (const input of markers) {
+      const candidate = candidateSeedFromMarker(input);
+      if (!candidate || seenDigests.has(candidate.digest))
+        continue;
+      seenDigests.add(candidate.digest);
+      if (candidateAgreesWithOwnIdentity(candidate.salt, candidate.digest)) {
+        return candidate.digest;
+      }
+    }
+    return;
+  }
   function recoverPersistedMarkers(markers) {
     const seed = extractReceiptReadbackSeed(markers);
     if (seed.status !== "ready")
@@ -11017,6 +11075,39 @@ function createSessionRuntime(options) {
     initialized = true;
     return true;
   }
+  function classifyMarkersFromParts(parts2) {
+    const allMarkers = [];
+    for (const part of parts2)
+      collectReceiptMarkers(part, allMarkers);
+    if (allMarkers.length === 0)
+      return { kind: "foreign-empty" };
+    const ownDigest = resolveOwnRegistrationDigest(allMarkers);
+    if (ownDigest !== undefined) {
+      return {
+        kind: "own",
+        markers: filterMarkersByRegistration(allMarkers, ownDigest)
+      };
+    }
+    for (const input of allMarkers) {
+      const validation = validateReceiptMarker(input);
+      if (validation.status !== "valid") {
+        return { kind: "ambiguous" };
+      }
+      const candidate = candidateSeedFromMarker(input);
+      if (candidate === undefined) {
+        return { kind: "ambiguous" };
+      }
+    }
+    return { kind: "foreign-empty" };
+  }
+  function publishEmptyMarkers(parts2, allowFresh) {
+    if (allowFresh && !parts2.some((part) => containsGuardHistory(part))) {
+      publishFresh();
+    } else {
+      retryableEmptyHistory = true;
+      publishUnavailable();
+    }
+  }
   async function initializeSession(sessionID, allowFresh) {
     const reader = options.hostReadback?.readSessionParts;
     if (!reader) {
@@ -11030,19 +11121,16 @@ function createSessionRuntime(options) {
       publishUnavailable();
       return;
     }
-    const markers = [];
-    for (const part of parts2)
-      collectReceiptMarkers(part, markers);
-    if (markers.length === 0) {
-      if (allowFresh && !parts2.some((part) => containsGuardHistory(part))) {
-        publishFresh();
-      } else {
-        retryableEmptyHistory = true;
-        publishUnavailable();
-      }
+    const classification = classifyMarkersFromParts(parts2);
+    if (classification.kind === "ambiguous") {
+      publishUnavailable();
       return;
     }
-    if (!recoverPersistedMarkers(markers))
+    if (classification.kind === "foreign-empty") {
+      publishEmptyMarkers(parts2, allowFresh);
+      return;
+    }
+    if (!recoverPersistedMarkers(classification.markers))
       publishUnavailable();
   }
   async function recoverFromHost(sessionID, allowFresh = true) {
@@ -11080,12 +11168,15 @@ function createSessionRuntime(options) {
       markUnavailable();
       return;
     }
-    const markers = [];
-    for (const part of parts2)
-      collectReceiptMarkers(part, markers);
-    if (markers.length === 0)
+    const classification = classifyMarkersFromParts(parts2);
+    if (classification.kind === "foreign-empty")
       return;
-    const seed = extractReceiptReadbackSeed(markers);
+    if (classification.kind === "ambiguous") {
+      markUnavailable();
+      return;
+    }
+    const ownMarkers = classification.markers;
+    const seed = extractReceiptReadbackSeed(ownMarkers);
     if (seed.status !== "ready") {
       markUnavailable();
       return;
@@ -11099,7 +11190,7 @@ function createSessionRuntime(options) {
       markUnavailable();
       return;
     }
-    const recovered = childLedger.recoverReadback(markers);
+    const recovered = childLedger.recoverReadback(ownMarkers);
     if (recovered.status === "rejected") {
       markUnavailable();
       return;

package/dist/lib/config-schema.d.ts

@@ -87,6 +87,72 @@ export declare const CategoryOverlaySchema: z.ZodObject<{
         deny: "deny";
     }>>]>>>;
 }, z.core.$strict>;
+export declare const PiSubagentsAgentOverlaySchema: z.ZodObject<{
+    thinking: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+    max_turns: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+}, z.core.$strict>;
+export declare const PiSubagentsCategoryOverlaySchema: z.ZodObject<{
+    thinking: z.ZodOptional<z.ZodEnum<{
+        off: "off";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+    max_turns: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodString>;
+    skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+}, z.core.$strict>;
+export declare const PiSubagentsSchema: z.ZodDefault<z.ZodObject<{
+    categories: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        thinking: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        tools: z.ZodOptional<z.ZodString>;
+        skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    }, z.core.$strict>>>;
+    agents: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        thinking: z.ZodOptional<z.ZodEnum<{
+            off: "off";
+            minimal: "minimal";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        tools: z.ZodOptional<z.ZodString>;
+        skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodString]>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>;
+/**
+ * Fields in PiSubagentsAgentOverlaySchema/PiSubagentsCategoryOverlaySchema that
+ * require a project-or-higher trust source. Project config cannot grant
+ * `thinking`, `tools`, or `skills` to an exported persona; `max_turns` is
+ * trust-any. Mirrors the hand-coded `PI_SUBAGENTS_PROTECTED_FIELDS` set in
+ * `src/lib/config.ts`.
+ */
+export declare const PI_SUBAGENTS_PROTECTED_FIELDS: readonly string[];
 export declare const BootstrapSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     file: z.ZodOptional<z.ZodString>;

package/dist/lib/config.d.ts

@@ -22,6 +22,10 @@ export interface SourceAwareConfigResult {
     config: SystematicConfig;
     overlays: SourcedOverlayConfigMap;
 }
+export interface PiSubagentsOverlayMap {
+    categories?: OverlayConfigMap;
+    agents?: OverlayConfigMap;
+}
 export interface SystematicConfig {
     disabled_skills: string[];
     disabled_agents: string[];
@@ -30,6 +34,7 @@ export interface SystematicConfig {
     workflow_guard: WorkflowGuardConfig;
     agents?: OverlayConfigMap;
     categories?: OverlayConfigMap;
+    pi_subagents?: PiSubagentsOverlayMap;
     skills_as_commands: boolean;
 }
 export declare const DEFAULT_CONFIG: SystematicConfig;
@@ -47,8 +52,17 @@ export declare function computeDroppedNames(names: readonly string[], allowedSet
  * Passing a fresh set per load ensures no cross-load suppression.
  */
 export declare function warnDroppedNames(dropped: string[], field: string, warned: Set<string>, removalVersion?: string): void;
-export declare function loadConfig(projectDir: string): SystematicConfig;
-export declare function loadConfigWithSources(projectDir: string): SourceAwareConfigResult;
+export interface LoadConfigOptions {
+    /**
+     * When false, the project-level config source (`<cwd>/.opencode/systematic.json`)
+     * is not loaded at all — not merged, not trust-stripped, entirely absent from
+     * the source chain. Used by global-scoped pi-subagents export so it never
+     * absorbs cwd project overlays (plan R7/R19). Defaults to true.
+     */
+    includeProject?: boolean;
+}
+export declare function loadConfig(projectDir: string, options?: LoadConfigOptions): SystematicConfig;
+export declare function loadConfigWithSources(projectDir: string, options?: LoadConfigOptions): SourceAwareConfigResult;
 export declare function getConfigPaths(projectDir: string): {
     customConfig?: string | undefined;
     customDir?: string | undefined;

package/dist/lib/pi-subagents-export.d.ts

@@ -0,0 +1,143 @@
+/**
+ * pi-subagents export lifecycle: resolve, preview, export, refresh, cleanup.
+ *
+ * Writes user-chosen agents dirs ($PI_CODING_AGENT_DIR/agents or
+ * <cwd>/.pi/agents). Batch-transactional with rollback: if any file write or
+ * the manifest write fails, the operation rolls back to the pre-operation
+ * state. Rollback reports any restoration failures explicitly.
+ *
+ * Manifest tracks ownership. Malformed or hostile manifests cause every
+ * lifecycle verb to refuse before mutation. No writes from module import.
+ */
+export type ExportScope = 'project' | 'global';
+/**
+ * Scope-appropriate config resolution for export/preview/refresh. When
+ * provided, the effective config (`user → project → custom` for project
+ * scope; `user → custom` for global scope — never absorbing cwd project
+ * overlays) is applied to each exported persona's frontmatter: `model`
+ * resolved from the `categories`/`agents` overlay (per-agent beats category;
+ * `model: null` omits) and Pi-native `pi_subagents` fields (`thinking`,
+ * `max_turns`, `tools`, `skills`) resolved from the `pi_subagents`
+ * namespace after trust filtering. Omitting `configOptions` preserves the
+ * model-free, config-neutral export (backward compatible default).
+ */
+export interface ExportConfigOptions {
+    scope: ExportScope;
+    cwd: string;
+}
+export declare const MANIFEST_FILENAME = ".systematic-personas.json";
+/** Exclusive per-root mutation lock. Guards export/refresh/cleanup; preview is lock-free. */
+export declare const LOCK_FILENAME = ".systematic-personas.lock";
+export interface ManifestFileEntry {
+    filename: string;
+    hash: string;
+    status: 'exported' | 'exported-with-warning';
+}
+export interface PiSubagentsManifest {
+    generatedAt: string;
+    agentsRoot: string;
+    files: ManifestFileEntry[];
+}
+/**
+ * Strict manifest read result — distinguishes absent from malformed.
+ *
+ *   absent   → no manifest file; operations proceed as first-export.
+ *   ok       → valid manifest, returned in `manifest`.
+ *   malformed → manifest file exists but is invalid (bad JSON, wrong schema,
+ *               duplicate filenames, unsafe filenames). Operations must refuse.
+ */
+export type ManifestReadResult = {
+    kind: 'absent';
+} | {
+    kind: 'ok';
+    manifest: PiSubagentsManifest;
+} | {
+    kind: 'malformed';
+    error: string;
+};
+export declare function resolveAgentsRoot(scope: ExportScope, cwd: string): string;
+/**
+ * Resolve the safety anchor for a scope: the topmost directory whose
+ * descendants (down to agentsRoot) are walked and lstat-checked for
+ * symlinks/non-directories. Never inspects ancestors above this anchor
+ * (avoids false positives from OS-level ancestor symlinks, e.g. macOS
+ * `/var` -> `/private/var`).
+ *
+ * - project: cwd
+ * - global with PI_CODING_AGENT_DIR set: the env dir's PARENT (so the env
+ *   dir itself is included in the walk and checked)
+ * - global without PI_CODING_AGENT_DIR: homedir
+ */
+export declare function resolveAnchor(scope: ExportScope, cwd: string): string;
+export declare function readManifestStrict(agentsRoot: string): ManifestReadResult;
+/**
+ * Convenience wrapper: returns the manifest for 'ok', null for 'absent', throws
+ * a structured Error for 'malformed'. Used by callers that already distinguished absent.
+ */
+export declare function readManifest(agentsRoot: string): PiSubagentsManifest | null;
+export declare function writeManifest(agentsRoot: string, manifest: PiSubagentsManifest): void;
+export interface TxResult {
+    ok: boolean;
+    error?: string;
+    rollbackFailed: string[];
+}
+/**
+ * Run a sequence of filesystem operations under snapshot/rollback protection.
+ *
+ * 1. Snapshot `pathsToWatch` (current content or absent marker).
+ * 2. Execute each `op` in order. On the first throw, stop.
+ * 3. On any failure: restore all watched paths to their snapshotted state.
+ *    Returns `{ ok: false, error, rollbackFailed }` — `rollbackFailed` lists
+ *    paths whose restoration itself failed (partial rollback, reported honestly).
+ * 4. On full success: returns `{ ok: true, rollbackFailed: [] }`.
+ *
+ * Exported for direct testing; also used by all production commit/delete paths.
+ */
+export declare function runWithRollback(pathsToWatch: string[], ops: Array<() => void>): TxResult;
+export type PlanAction = {
+    action: 'create';
+    filename: string;
+} | {
+    action: 'update';
+    filename: string;
+} | {
+    action: 'refuse';
+    filename: string;
+    reason: string;
+} | {
+    action: 'remove';
+    filename: string;
+} | {
+    action: 'skip';
+    filename: string;
+};
+export interface ExportPlan {
+    status: 'ok' | 'error';
+    error?: string;
+    agentsRoot: string;
+    actions: PlanAction[];
+}
+export declare function preview(agentsRoot: string, configOptions?: ExportConfigOptions): ExportPlan;
+export interface ExportResult {
+    status: 'ok' | 'error';
+    written: number;
+    skipped: number;
+    refused: Array<{
+        filename: string;
+        reason: string;
+    }>;
+    error?: string;
+}
+export declare function exportPersonas(agentsRoot: string, configOptions?: ExportConfigOptions): ExportResult;
+export interface RefreshResult {
+    status: 'ok' | 'error';
+    updated: number;
+    skippedUnowned: number;
+    error?: string;
+}
+export declare function refresh(agentsRoot: string, configOptions?: ExportConfigOptions): RefreshResult;
+export interface CleanupResult {
+    status: 'ok' | 'error';
+    error?: string;
+}
+export declare function cleanup(agentsRoot: string, configOptions?: ExportConfigOptions): CleanupResult;

package/dist/lib/pi-subagents-personas.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Pure persona generation logic for pi-subagents interop.
+ *
+ * Contains the curated persona list, compatibility screening, content
+ * generation, and generateAll(). Importable from both src/ and scripts/.
+ * No filesystem writes; no CLI entrypoint.
+ */
+/** Compatibility severity: info = fully usable, warning = may differ, critical = excluded. */
+export type CompatibilitySeverity = 'info' | 'warning' | 'critical';
+/** Result of classifying a persona's pi-subagents compatibility. */
+export interface CompatibilityStatus {
+    severity: CompatibilitySeverity;
+    /** Human-readable reasons for the severity (empty for info). */
+    reasons: string[];
+}
+/** Per-persona entry in the manifest. */
+export interface ManifestEntry {
+    /** Emitted filename, e.g. `systematic-best-practices-researcher.md`. */
+    filename: string;
+    /** Export status. */
+    status: 'exported' | 'exported-with-warning' | 'excluded-critical';
+    /** Repo-relative source path, e.g. `agents/research/best-practices-researcher.md`. */
+    sourceRelPath: string;
+    /** SHA-256 hex of the generated content (only for exported entries). */
+    hash: string;
+    /** Generated content (only for exported entries). */
+    content?: string;
+    /** Human-readable reason (for excluded-critical and exported-with-warning). */
+    reason?: string;
+}
+/**
+ * The authoritative curated-include list with per-persona compatibility
+ * rationale. Only personas in this list are candidates for export.
+ *
+ * Exclusion rationale (not in list):
+ *   - agents/workflow/systematic-implementer.md — CRITICAL: dispatched-by-parent assumption.
+ *   - agents/design/design-iterator.md — CRITICAL: requires agent-browser + skill load.
+ *   - agents/review/agent-native-reviewer.md — CRITICAL: Systematic/OpenCode-specific context.
+ *   - agents/review/project-standards-reviewer.md — CRITICAL: requires orchestrator <standards-paths>.
+ *   - agents/review/kieran-typescript-reviewer.md — WARNING: excluded by plan recommendation.
+ *   - agents/research/slack-researcher.md — CRITICAL: requires Slack MCP environment.
+ *   - agents/research/learnings-researcher.md — CRITICAL: references Systematic skill paths.
+ *   - agents/workflow/pr-comment-resolver.md — WARNING: "Spawned by the resolve-pr-feedback skill".
+ */
+export interface CuratedPersonaEntry {
+    relPath: string;
+    rationale: string;
+}
+export declare const CURATED_PERSONAS: CuratedPersonaEntry[];
+/**
+ * Sanitize a persona name for use as a pi-subagents filename stem.
+ * Returns empty string if no safe characters remain — callers must reject
+ * empty to avoid producing `systematic-.md`.
+ */
+export declare function sanitizeName(name: string): string;
+export declare function classifyCompatibility(content: string): CompatibilityStatus;
+export declare function generatePersonaContent(sourceRef: string, rawContent: string): string | null;
+export declare function generatePersonaManifest(sourceRelPath: string, rawContent: string, _repoRoot: string): ManifestEntry;
+/**
+ * Generate all curated personas from repoRoot/agents/.
+ * Throws on collision, new critical coupling, or read errors.
+ * Pure — no writes.
+ */
+export declare function generateAll(repoRoot: string): ManifestEntry[];