@rizom/ops 0.2.0-alpha.6 → 0.2.0-alpha.600

package/dist/legacy-pilot-migration.d.ts

@@ -0,0 +1,11 @@
+import { type CohortConfig, type PilotConfig } from "./schema";
+/** Offline-only conversion. Active desired-state loading never calls this. */
+export declare function migrateLegacyPilotConfig(input: unknown): PilotConfig;
+/** Offline-only cohort conversion. */
+export declare function migrateLegacyCohortConfig(input: unknown): CohortConfig;
+/** Offline-only YAML rewrite that retains comments while changing the schema. */
+export declare function migrateLegacyPilotYaml(input: string): string;
+/** Offline-only cohort rewrite that retains comments while changing selection. */
+export declare function migrateLegacyCohortYaml(input: string): string;
+export declare function renderPilotConfig(config: PilotConfig): string;
+export declare function renderCohortConfig(config: CohortConfig): string;

package/dist/legacy-projection-job-recovery.d.ts

@@ -0,0 +1,29 @@
+import { type JobInfo } from "@brains/job-queue";
+import { z } from "@brains/utils/zod";
+export declare const LEGACY_PROJECTION_JOB_TYPES: readonly ["conversation-memory:project", "skill:project", "swot:derive", "topic:project"];
+export declare const legacyProjectionJobTypeSchema: z.ZodEnum<{
+    "conversation-memory:project": "conversation-memory:project";
+    "skill:project": "skill:project";
+    "swot:derive": "swot:derive";
+    "topic:project": "topic:project";
+}>;
+export type LegacyProjectionJobType = z.output<typeof legacyProjectionJobTypeSchema>;
+export declare const LEGACY_PROJECTION_RETIREMENT_REASON = "Retired legacy projection job superseded by scheduler-owned projections";
+export interface RetireLegacyProjectionJobOptions {
+    databasePath: string;
+    jobId: string;
+    jobType: LegacyProjectionJobType;
+    confirmation?: string | undefined;
+    dryRun?: boolean | undefined;
+    now?: (() => number) | undefined;
+}
+export interface RetireLegacyProjectionJobResult {
+    databasePath: string;
+    job: Pick<JobInfo, "id" | "type" | "status" | "retryCount" | "maxRetries" | "createdAt" | "startedAt" | "completedAt">;
+    retired: boolean;
+}
+/**
+ * Retire one exact pre-scheduler projection job after proving that no attempt
+ * owns it. This is deliberately not a general job cancellation API.
+ */
+export declare function retireLegacyProjectionJob(options: RetireLegacyProjectionJobOptions): Promise<RetireLegacyProjectionJobResult>;

package/dist/load-registry.d.ts

@@ -1,4 +1,4 @@
-import { type PilotConfig, type PilotPreset } from "./schema";
+import { type AnchorKind, type CohortConfig, type PilotConfig, type CanonicalBundleId, type UserConfig } from "./schema";
 export type ExternalStatus = "unknown" | "ready" | "failed";
 export type SnapshotStatus = "present" | "missing";
 export interface ObservedUserStatus {
@@ -11,19 +11,95 @@ export interface ResolvedCohort {
     id: string;
     members: string[];
     brainVersionOverride?: string;
-    presetOverride?: PilotPreset;
+    bundlesOverride?: CanonicalBundleId[];
+    addOverride?: string[];
+    removeOverride?: string[];
     aiApiKeyOverride?: string;
+    gitSyncTokenOverride?: string;
+}
+export interface ResolvedAnchorProfileSocialLink {
+    platform: "github" | "instagram" | "linkedin" | "email" | "website";
+    url: string;
+    label?: string;
+}
+export interface ResolvedAnchorProfile {
+    name: string;
+    description?: string;
+    website?: string;
+    email?: string;
+    story?: string;
+    socialLinks?: ResolvedAnchorProfileSocialLink[];
+}
+export interface ResolvedSetupDelivery {
+    delivery: "email";
+    email: string;
+}
+export interface ResolvedAtprotoJetstreamConfig {
+    enabled?: boolean | undefined;
+    endpoint?: string | undefined;
+    replayWindowSeconds?: number | undefined;
+    denyDids?: string[] | undefined;
+    denyDomains?: string[] | undefined;
+    skillKeywords?: string[] | undefined;
+    queueLimit?: number | undefined;
+    concurrency?: number | undefined;
+    perDidCooldownSeconds?: number | undefined;
+    fetchBudgetPerMinute?: number | undefined;
+    newAgentsPerHour?: number | undefined;
+    pendingCandidateCeiling?: number | undefined;
+    staleCandidateRetentionDays?: number | undefined;
+    requestTimeoutMs?: number | undefined;
+    maxResponseBytes?: number | undefined;
+    maxRedirects?: number | undefined;
+    retryAttempts?: number | undefined;
+    heartbeatIntervalHours?: number | undefined;
+}
+export interface ResolvedAtprotoConfig {
+    identifier: string;
+    /** Owner account DID served at /.well-known/atproto-did for handle verification. */
+    accountDid?: string | undefined;
+    /** Whether this account publishes the canonical ai.rizom.brain.* schemas. */
+    lexiconAuthority?: boolean | undefined;
+    /** Per-brain bounded Jetstream canary configuration. */
+    jetstream?: ResolvedAtprotoJetstreamConfig | undefined;
+}
+export interface ResolvedPlaybooksConfig {
+    onboarding?: boolean | undefined;
+}
+export interface ResolvedSiteOverride {
+    package: string;
+    version?: string | undefined;
+    theme?: string | undefined;
+    themeVersion?: string | undefined;
 }
 export interface ResolvedUserIdentity {
     handle: string;
     cohort: string;
     brainVersion: string;
-    model: "rover";
-    preset: PilotPreset;
+    bundleContract: PilotConfig["bundleContract"];
+    bundles: CanonicalBundleId[];
+    add: string[];
+    remove: string[];
     domain: string;
+    cloudflareZoneId?: string | undefined;
     contentRepo: string;
+    profileKind?: string | undefined;
+    anchorKind?: AnchorKind | undefined;
+    embeddingEnabled?: boolean | undefined;
+    plugins?: UserConfig["plugins"];
+    spaces?: string[] | undefined;
+    topicExtractionEnabled?: boolean | undefined;
+    skillDerivationEnabled?: boolean | undefined;
+    swotDerivationEnabled?: boolean | undefined;
+    siteOverride?: ResolvedSiteOverride;
     discordEnabled: boolean;
+    discordAnchorUserId?: string;
     effectiveAiApiKey: string;
+    effectiveGitSyncToken: string;
+    setup?: ResolvedSetupDelivery;
+    atproto?: ResolvedAtprotoConfig;
+    playbooks?: ResolvedPlaybooksConfig;
+    anchorProfile: ResolvedAnchorProfile;
     snapshotStatus: SnapshotStatus;
 }
 export interface ResolvedUser extends ResolvedUserIdentity {
@@ -40,7 +116,13 @@ export interface PilotRegistry {
     cohorts: ResolvedCohort[];
     users: ResolvedUser[];
 }
-declare class PilotRegistryError extends Error {
+export interface LoadedCohortFile {
+    id: string;
+    data: CohortConfig;
 }
 export declare function loadPilotRegistry(rootDir: string, options?: LoadPilotRegistryOptions): Promise<PilotRegistry>;
-export { PilotRegistryError };
+/**
+ * Resolve a user's desired state from the user → cohort → pilot cascade.
+ * Pure: the snapshot status is filesystem state and is added by the loader.
+ */
+export declare function resolveUserIdentity(user: UserConfig, cohort: LoadedCohortFile, pilot: PilotConfig): Omit<ResolvedUserIdentity, "snapshotStatus">;

package/dist/observed-status.d.ts

@@ -1,4 +1,4 @@
-import type { FetchLike } from "@brains/utils/origin-ca";
+import type { FetchLike } from "@brains/utils/fetch-like";
 import type { ObservedUserStatus, ResolvedUserIdentity } from "./load-registry";
 export interface LookupResult {
     address: string;

package/dist/onboard-user.d.ts

@@ -1,2 +1,2 @@
-import { type UserRunner } from "./reconcile-lib";
-export declare function onboardUser(rootDir: string, handle: string, runner?: UserRunner): Promise<void>;
+import { type UserRunner, type ContentRepoSyncOptions } from "./reconcile-lib";
+export declare function onboardUser(rootDir: string, handle: string, runner?: UserRunner, contentRepoOptions?: ContentRepoSyncOptions): Promise<void>;

package/dist/parse-args.d.ts

@@ -1,11 +1,3 @@
-export interface ParsedArgs {
-    command: string;
-    args: string[];
-    flags: {
-        help?: boolean | undefined;
-        version?: boolean | undefined;
-        dryRun?: boolean | undefined;
-        pushTo?: string | undefined;
-    };
-}
+import { type ParsedCliArgs } from "@brains/deploy-support/cli-kit";
+export type ParsedArgs = ParsedCliArgs;
 export declare function parseArgs(argv: string[]): ParsedArgs;

package/dist/preview-domain.d.ts

@@ -0,0 +1,9 @@
+export interface PreviewDomainOptions {
+    sharedDomain?: string | undefined;
+}
+/**
+ * Public operator-facing wrapper around the runtime's preview-domain rule.
+ * Keeping deploy resolution on this function prevents DNS, proxy, and runtime
+ * metadata from drifting onto different host shapes.
+ */
+export declare function derivePreviewDomain(domain: string, options?: PreviewDomainOptions): string;

package/dist/reconcile-all.d.ts

@@ -1,2 +1,2 @@
-import { type UserRunner } from "./reconcile-lib";
-export declare function reconcileAll(rootDir: string, runner?: UserRunner): Promise<void>;
+import { type UserRunner, type ContentRepoSyncOptions } from "./reconcile-lib";
+export declare function reconcileAll(rootDir: string, runner?: UserRunner, contentRepoOptions?: ContentRepoSyncOptions): Promise<void>;

package/dist/reconcile-cohort.d.ts

@@ -1,2 +1,2 @@
-import { type UserRunner } from "./reconcile-lib";
-export declare function reconcileCohort(rootDir: string, cohortId: string, runner?: UserRunner): Promise<void>;
+import { type UserRunner, type ContentRepoSyncOptions } from "./reconcile-lib";
+export declare function reconcileCohort(rootDir: string, cohortId: string, runner?: UserRunner, contentRepoOptions?: ContentRepoSyncOptions): Promise<void>;

package/dist/reconcile-dry-run.d.ts

@@ -0,0 +1,9 @@
+export interface ReconcileDryRunResult {
+    firstPassChangedFiles: string[];
+    secondPassChangedFiles: string[];
+}
+/**
+ * Reconcile an isolated copy twice with external content-repo access disabled.
+ * The source repository is never written.
+ */
+export declare function dryRunReconcileAll(rootDir: string): Promise<ReconcileDryRunResult>;

package/dist/reconcile-lib.d.ts

@@ -1,7 +1,9 @@
+import { type ContentRepoSyncOptions } from "./content-repo";
 import { type PilotRegistry, type ResolvedUser } from "./load-registry";
 import type { UserRunner } from "./user-runner";
-export type { UserRunResult, UserRunner } from "./user-runner";
-export declare function runUsers(rootDir: string, registry: PilotRegistry, users: ResolvedUser[], runner?: UserRunner): Promise<void>;
+export type { ContentRepoSyncOptions } from "./content-repo";
+export type { ContentRepoFile, UserRunResult, UserRunner } from "./user-runner";
+export declare function runUsers(rootDir: string, registry: PilotRegistry, users: ResolvedUser[], runner?: UserRunner, contentRepoOptions?: ContentRepoSyncOptions): Promise<void>;
 export declare function findUser(rootDir: string, handle: string): Promise<{
     registry: PilotRegistry;
     user: ResolvedUser;

package/dist/run-command.d.ts

@@ -1,10 +1,14 @@
-import type { FetchLike } from "@brains/utils/origin-ca";
-import type { LoadPilotRegistryOptions } from "./load-registry";
+import type { FetchLike } from "@brains/utils/fetch-like";
+import { type CommandDefinition, type FlagDefinitions, type ParsedCliArgs } from "@brains/deploy-support/cli-kit";
+import { type LoadPilotRegistryOptions } from "./load-registry";
 import { type LookupHost } from "./observed-status";
-import type { ParsedArgs } from "./parse-args";
-import { type RunCommand as OpsRunCommand } from "./run-subprocess";
+import { type RunCommand as OpsRunCommand } from "@brains/deploy-support/run-subprocess";
 import { type SshKeygen } from "./ssh-key-bootstrap";
+import type { PilotOffboardDriver } from "./user-offboard";
 import type { UserRunner } from "./user-runner";
+import type { cleanupDirectorySyncStress, runDeployedDirectorySyncStress, verifyDirectorySyncStressAccess } from "./directory-sync-stress-system";
+import type { cleanupHealthWatchdogSmoke, runHealthWatchdogSmoke } from "./health-watchdog-smoke";
+import type { retireLegacyProjectionJob } from "./legacy-projection-job-recovery";
 export interface CommandResult {
     success: boolean;
     message?: string;
@@ -15,8 +19,20 @@ export interface CommandDependencies extends LoadPilotRegistryOptions {
     logger?: ((message: string) => void) | undefined;
     fetchImpl?: FetchLike | undefined;
     lookupHost?: LookupHost | undefined;
-    secretRunCommand?: OpsRunCommand | undefined;
+    verificationRetryAttempts?: number | undefined;
+    verificationRetryDelayMs?: number | undefined;
+    sleep?: ((delayMs: number) => Promise<void>) | undefined;
     bootstrapRunCommand?: OpsRunCommand | undefined;
+    imageLockRunCommand?: OpsRunCommand | undefined;
     sshKeygen?: SshKeygen | undefined;
+    directorySyncStressRunner?: typeof runDeployedDirectorySyncStress | undefined;
+    directorySyncStressAccessRunner?: typeof verifyDirectorySyncStressAccess | undefined;
+    directorySyncStressCleanupRunner?: typeof cleanupDirectorySyncStress | undefined;
+    healthWatchdogSmokeRunner?: typeof runHealthWatchdogSmoke | undefined;
+    healthWatchdogSmokeCleanupRunner?: typeof cleanupHealthWatchdogSmoke | undefined;
+    legacyProjectionJobRecoveryRunner?: typeof retireLegacyProjectionJob | undefined;
+    pilotOffboardDriver?: PilotOffboardDriver | undefined;
 }
-export declare function runCommand(parsed: ParsedArgs, dependencies?: CommandDependencies): Promise<CommandResult>;
+export declare const globalFlags: FlagDefinitions;
+export declare const commands: readonly CommandDefinition<CommandDependencies, CommandResult>[];
+export declare function runCommand(parsed: ParsedCliArgs, dependencies?: CommandDependencies): Promise<CommandResult>;

package/dist/runtime-image-lock.d.ts

@@ -0,0 +1,12 @@
+import type { RequiredImage } from "./image-types";
+import { type RunCommand } from "@brains/deploy-support/run-subprocess";
+/** Operator-owned build inputs, not generated per-user deploy output. */
+export declare function runtimeImageLockDirectory(image: RequiredImage): string;
+/** Fail before publishing when a required build has no reviewed, matching inputs. */
+export declare function assertRuntimeImageLock(rootDir: string, image: RequiredImage): Promise<void>;
+/**
+ * Resolve once for operator review; CI and Docker only consume the frozen result.
+ * Existing entries are never refreshed or overwritten. Failed new entries retain
+ * their incomplete marker and diagnostic files and cannot be used by a build.
+ */
+export declare function lockRuntimeImage(rootDir: string, image: RequiredImage, run?: RunCommand): Promise<"created" | "existing">;

package/dist/schema.d.ts

@@ -1,86 +1,164 @@
-import { z } from "@brains/utils";
-export declare const presetSchema: z.ZodEnum<["core", "default", "pro"]>;
+import { z } from "@brains/utils/zod";
 export declare const exactVersionSchema: z.ZodString;
 export declare const handleSchema: z.ZodString;
 export declare const secretNameSchema: z.ZodString;
+export declare const agePublicKeySchema: z.ZodString;
+export declare const CAPABILITY_BUNDLE_CONTRACT: "capability-bundles-v1";
+export declare const canonicalBundleIdSchema: z.ZodEnum<{
+    core: "core";
+    media: "media";
+    automation: "automation";
+    web: "web";
+    chat: "chat";
+    site: "site";
+    publishing: "publishing";
+    federation: "federation";
+    team: "team";
+}>;
+export type CanonicalBundleId = z.output<typeof canonicalBundleIdSchema>;
+/**
+ * The profile kinds the runtime's profile plugin registers. A user config
+ * selecting anything else composes a brain that fails at boot, so reject it
+ * at parse time. Kept in lockstep with @brains/profile BUILT_IN_PROFILE_KINDS
+ * by a test. Collective/organization brains use "organization".
+ */
+export declare const PROFILE_KINDS: readonly ["professional", "team", "organization"];
+export declare const profileKindSchema: z.ZodEnum<{
+    professional: "professional";
+    team: "team";
+    organization: "organization";
+}>;
+/**
+ * Who owns the brain in its auth service. "person" (the runtime default) makes
+ * the first passkey holder a permanent owner; "team" and "organization" make
+ * the brain collectively owned, so admins can be replaced. Kept in lockstep
+ * with @brains/auth-service AUTH_BRAIN_ANCHOR_CONFIG_KINDS by a test.
+ */
+export declare const ANCHOR_KINDS: readonly ["person", "team", "organization"];
+export declare const anchorKindSchema: z.ZodEnum<{
+    person: "person";
+    team: "team";
+    organization: "organization";
+}>;
+export type AnchorKind = z.output<typeof anchorKindSchema>;
+declare const canonicalBundlesSchema: z.ZodArray<typeof canonicalBundleIdSchema>;
+declare const memberIdsSchema: z.ZodArray<z.ZodString>;
+/** Sole active desired-state contract for the canonical brain. */
 export declare const pilotSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
     brainVersion: z.ZodString;
-    model: z.ZodLiteral<"rover">;
+    bundleContract: z.ZodLiteral<typeof CAPABILITY_BUNDLE_CONTRACT>;
+    bundles: typeof canonicalBundlesSchema;
+    add: z.ZodOptional<typeof memberIdsSchema>;
+    remove: z.ZodOptional<typeof memberIdsSchema>;
     githubOrg: z.ZodString;
     contentRepoPrefix: z.ZodString;
     domainSuffix: z.ZodString;
-    preset: z.ZodEnum<["core", "default", "pro"]>;
     aiApiKey: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    schemaVersion: 1;
-    brainVersion: string;
-    model: "rover";
-    githubOrg: string;
-    contentRepoPrefix: string;
-    domainSuffix: string;
-    preset: "default" | "core" | "pro";
-    aiApiKey: string;
-}, {
-    schemaVersion: 1;
-    brainVersion: string;
-    model: "rover";
-    githubOrg: string;
-    contentRepoPrefix: string;
-    domainSuffix: string;
-    preset: "default" | "core" | "pro";
-    aiApiKey: string;
+    gitSyncToken: z.ZodString;
+    contentRepoAdminToken: z.ZodString;
+    agePublicKey: z.ZodString;
+}, z.core.$strict>;
+export type PilotConfig = z.output<typeof pilotSchema>;
+export declare const cohortSchema: z.ZodObject<{
+    members: z.ZodArray<z.ZodString>;
+    brainVersionOverride: z.ZodOptional<z.ZodString>;
+    bundlesOverride: z.ZodOptional<typeof canonicalBundlesSchema>;
+    addOverride: z.ZodOptional<typeof memberIdsSchema>;
+    removeOverride: z.ZodOptional<typeof memberIdsSchema>;
+    aiApiKeyOverride: z.ZodOptional<z.ZodString>;
+    gitSyncTokenOverride: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CohortConfig = z.output<typeof cohortSchema>;
+declare const anchorProfileSocialLinkSchema: z.ZodObject<{
+    platform: z.ZodEnum<{
+        github: "github";
+        instagram: "instagram";
+        linkedin: "linkedin";
+        email: "email";
+        website: "website";
+    }>;
+    url: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}>;
+declare const anchorProfileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    website: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    story: z.ZodOptional<z.ZodString>;
+    socialLinks: z.ZodOptional<z.ZodArray<typeof anchorProfileSocialLinkSchema>>;
 }>;
+declare const setupDeliverySchema: z.ZodObject<{
+    delivery: z.ZodLiteral<"email">;
+    email: z.ZodString;
+}>;
+declare const atprotoJetstreamSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    replayWindowSeconds: z.ZodOptional<z.ZodNumber>;
+    denyDids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    denyDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skillKeywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    queueLimit: z.ZodOptional<z.ZodNumber>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    perDidCooldownSeconds: z.ZodOptional<z.ZodNumber>;
+    fetchBudgetPerMinute: z.ZodOptional<z.ZodNumber>;
+    newAgentsPerHour: z.ZodOptional<z.ZodNumber>;
+    pendingCandidateCeiling: z.ZodOptional<z.ZodNumber>;
+    staleCandidateRetentionDays: z.ZodOptional<z.ZodNumber>;
+    requestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxResponseBytes: z.ZodOptional<z.ZodNumber>;
+    maxRedirects: z.ZodOptional<z.ZodNumber>;
+    retryAttempts: z.ZodOptional<z.ZodNumber>;
+    heartbeatIntervalHours: z.ZodOptional<z.ZodNumber>;
+}>;
+declare const atprotoSchema: z.ZodObject<{
+    identifier: z.ZodString;
+    accountDid: z.ZodOptional<z.ZodString>;
+    lexiconAuthority: z.ZodOptional<z.ZodBoolean>;
+    jetstream: z.ZodOptional<typeof atprotoJetstreamSchema>;
+}>;
+export declare const siteOverrideSchema: z.ZodObject<{
+    package: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    theme: z.ZodOptional<z.ZodString>;
+    themeVersion: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SiteOverrideConfig = z.output<typeof siteOverrideSchema>;
+declare const playbooksSchema: z.ZodObject<{
+    onboarding: z.ZodOptional<z.ZodBoolean>;
+}>;
+/** Config transport shape; plugin-owned schemas validate fields in the app. */
+declare const userPluginsSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 export declare const userSchema: z.ZodObject<{
     handle: z.ZodString;
     discord: z.ZodObject<{
         enabled: z.ZodBoolean;
-    }, "strict", z.ZodTypeAny, {
-        enabled: boolean;
-    }, {
-        enabled: boolean;
+        anchorUserId: z.ZodOptional<z.ZodString>;
     }>;
     aiApiKeyOverride: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    handle: string;
-    discord: {
-        enabled: boolean;
-    };
-    aiApiKeyOverride?: string | undefined;
-}, {
-    handle: string;
-    discord: {
-        enabled: boolean;
-    };
-    aiApiKeyOverride?: string | undefined;
-}>;
-export declare const cohortSchema: z.ZodEffects<z.ZodObject<{
-    members: z.ZodArray<z.ZodString, "many">;
-    brainVersionOverride: z.ZodOptional<z.ZodString>;
-    presetOverride: z.ZodOptional<z.ZodEnum<["core", "default", "pro"]>>;
-    aiApiKeyOverride: z.ZodOptional<z.ZodString>;
-}, "strict", z.ZodTypeAny, {
-    members: string[];
-    aiApiKeyOverride?: string | undefined;
-    brainVersionOverride?: string | undefined;
-    presetOverride?: "default" | "core" | "pro" | undefined;
-}, {
-    members: string[];
-    aiApiKeyOverride?: string | undefined;
-    brainVersionOverride?: string | undefined;
-    presetOverride?: "default" | "core" | "pro" | undefined;
-}>, {
-    members: string[];
-    aiApiKeyOverride?: string | undefined;
-    brainVersionOverride?: string | undefined;
-    presetOverride?: "default" | "core" | "pro" | undefined;
-}, {
-    members: string[];
-    aiApiKeyOverride?: string | undefined;
-    brainVersionOverride?: string | undefined;
-    presetOverride?: "default" | "core" | "pro" | undefined;
+    gitSyncTokenOverride: z.ZodOptional<z.ZodString>;
+    domainOverride: z.ZodOptional<z.ZodString>;
+    cloudflareZoneId: z.ZodOptional<z.ZodString>;
+    contentRepoOverride: z.ZodOptional<z.ZodString>;
+    profileKind: z.ZodOptional<typeof profileKindSchema>;
+    anchorKind: z.ZodOptional<typeof anchorKindSchema>;
+    plugins: z.ZodOptional<typeof userPluginsSchema>;
+    spaces: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    embeddingEnabled: z.ZodOptional<z.ZodBoolean>;
+    topicExtractionEnabled: z.ZodOptional<z.ZodBoolean>;
+    skillDerivationEnabled: z.ZodOptional<z.ZodBoolean>;
+    swotDerivationEnabled: z.ZodOptional<z.ZodBoolean>;
+    addOverride: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    removeOverride: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    siteOverride: z.ZodOptional<typeof siteOverrideSchema>;
+    setup: z.ZodOptional<typeof setupDeliverySchema>;
+    atproto: z.ZodOptional<typeof atprotoSchema>;
+    playbooks: z.ZodOptional<typeof playbooksSchema>;
+    anchorProfile: z.ZodOptional<typeof anchorProfileSchema>;
 }>;
-export type PilotConfig = z.infer<typeof pilotSchema>;
-export type UserConfig = z.infer<typeof userSchema>;
-export type CohortConfig = z.infer<typeof cohortSchema>;
-export type PilotPreset = z.infer<typeof presetSchema>;
+export type PilotConfigInput = z.input<typeof pilotSchema>;
+export type UserConfig = z.output<typeof userSchema>;
+export type UserConfigInput = z.input<typeof userSchema>;
+export type CohortConfigInput = z.input<typeof cohortSchema>;
+export {};

package/dist/secrets-encrypt.d.ts

@@ -0,0 +1,26 @@
+import { z } from "@brains/utils/zod";
+declare const encryptedUserSecretsSchema: z.ZodObject<{
+    gitSyncToken: z.ZodOptional<z.ZodString>;
+    discordBotToken: z.ZodOptional<z.ZodString>;
+    discordPublicKey: z.ZodOptional<z.ZodString>;
+    discordApplicationId: z.ZodOptional<z.ZodString>;
+    aiApiKey: z.ZodOptional<z.ZodString>;
+    atprotoAppPassword: z.ZodOptional<z.ZodString>;
+    certificatePem: z.ZodOptional<z.ZodString>;
+    privateKeyPem: z.ZodOptional<z.ZodString>;
+}>;
+export type EncryptedUserSecrets = z.output<typeof encryptedUserSecretsSchema>;
+export interface SecretsEncryptOptions {
+    env?: NodeJS.ProcessEnv | undefined;
+    logger?: ((message: string) => void) | undefined;
+    dryRun?: boolean | undefined;
+}
+export interface SecretsEncryptResult {
+    encryptedPath: string;
+    plaintextPath: string;
+    deletedPlaintext: boolean;
+    encryptedKeys: Array<keyof EncryptedUserSecrets>;
+    dryRun?: boolean | undefined;
+}
+export declare function encryptPilotSecrets(rootDir: string, handle: string, options?: SecretsEncryptOptions): Promise<SecretsEncryptResult>;
+export {};

package/dist/secrets-push.d.ts

@@ -1,4 +1,4 @@
-import { type RunCommand } from "./run-subprocess";
+import { type RunCommand } from "@brains/deploy-support/run-subprocess";
 export interface SecretsPushOptions {
     env?: NodeJS.ProcessEnv | undefined;
     logger?: ((message: string) => void) | undefined;
@@ -10,4 +10,4 @@ export interface SecretsPushResult {
     skippedKeys: string[];
     dryRun?: boolean | undefined;
 }
-export declare function pushPilotSecrets(rootDir: string, handle: string, options?: SecretsPushOptions): Promise<SecretsPushResult>;
+export declare function pushPilotSecrets(rootDir: string, options?: SecretsPushOptions): Promise<SecretsPushResult>;

package/dist/ssh-key-bootstrap.d.ts

@@ -1,26 +1 @@
-import { type FetchLike } from "@brains/utils/origin-ca";
-import { type RunCommand } from "./run-subprocess";
-export interface SshKeyBootstrapOptions {
-    env?: NodeJS.ProcessEnv | undefined;
-    fetchImpl?: FetchLike | undefined;
-    logger?: (message: string) => void;
-    pushTo?: string | undefined;
-    runCommand?: RunCommand | undefined;
-    sshKeygen?: SshKeygen | undefined;
-}
-export interface SshKeyBootstrapResult {
-    createdHetznerKey: boolean;
-    createdLocalKey: boolean;
-    privateKeyPath: string;
-    publicKeyPath: string;
-    sshKeyName: string;
-}
-export interface SshKeygen {
-    createEd25519KeyPair: (privateKeyPath: string, comment: string) => void;
-    derivePublicKey: (privateKeyPath: string) => string;
-}
-export declare function runPilotSshKeyBootstrap(rootDir: string, options?: SshKeyBootstrapOptions): Promise<{
-    success: boolean;
-    message?: string;
-}>;
-export declare function bootstrapPilotSshKey(rootDir: string, options?: SshKeyBootstrapOptions): Promise<SshKeyBootstrapResult>;
+export { bootstrapSshKey as bootstrapPilotSshKey, runSshKeyBootstrap as runPilotSshKeyBootstrap, type SshKeyBootstrapOptions, type SshKeyBootstrapResult, type SshKeygen, } from "@brains/deploy-support/ssh-key-bootstrap";

package/dist/stage-legacy-crossover.d.ts

@@ -0,0 +1,25 @@
+import { z } from "@brains/utils/zod";
+import { type CapabilityBundleReview } from "./capability-bundle-migration";
+import { siteOverrideSchema } from "./schema";
+export interface StagedCrossover {
+    outputDir: string;
+    changedFiles: string[];
+}
+declare const reviewedSitePinsSchema: z.ZodObject<{
+    sites: z.ZodRecord<z.ZodString, typeof siteOverrideSchema>;
+}, z.core.$strict>;
+type ReviewedSitePinManifest = z.output<typeof reviewedSitePinsSchema>;
+export type ReviewedSitePins = ReviewedSitePinManifest["sites"];
+export interface StageLegacyCrossoverOptions {
+    sitePins?: ReviewedSitePins | undefined;
+    bundleReview?: CapabilityBundleReview | undefined;
+}
+export declare function parseReviewedSitePins(input: string): ReviewedSitePins;
+export declare function loadReviewedSitePins(filePath: string): Promise<ReviewedSitePins>;
+export declare function loadCapabilityBundleReview(filePath: string): Promise<CapabilityBundleReview>;
+/**
+ * Build a complete review copy without mutating the source repository.
+ * This is offline migration tooling; active desired-state loading is canonical-only.
+ */
+export declare function stageLegacyCrossover(sourceDir: string, outputDir: string, options?: StageLegacyCrossoverOptions): Promise<StagedCrossover>;
+export {};

package/dist/stress-command.d.ts

@@ -0,0 +1,14 @@
+export interface StressCommandOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    stdin?: string;
+}
+export interface StressCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export type StressCommandRunner = (command: string, args: readonly string[], options?: StressCommandOptions) => Promise<StressCommandResult>;
+export declare const runStressCommand: StressCommandRunner;
+export declare function requireCommand(runner: StressCommandRunner, command: string, args: readonly string[], options?: StressCommandOptions): Promise<StressCommandResult>;
+export declare function commandError(command: string, args: readonly string[], result: StressCommandResult): Error;