@lumenflow/core 3.2.0 → 3.2.2

package/dist/schemas/lanes-config.js

@@ -0,0 +1,125 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Lanes Configuration Schemas
+ *
+ * Lane definitions, enforcement rules, lock policies, and lifecycle status.
+ *
+ * @module schemas/lanes-config
+ */
+import { z } from 'zod';
+/**
+ * WU-1325: Lock policy for lane-level WIP enforcement
+ *
+ * Controls how lane locks behave:
+ * - 'all' (default): Lock acquired on claim, held through block, released on done
+ * - 'active': Lock acquired on claim, released on block, re-acquired on unblock
+ * - 'none': No lock files created, WIP checking disabled
+ *
+ * @example
+ * ```yaml
+ * lanes:
+ *   definitions:
+ *     - name: 'Content: Documentation'
+ *       wip_limit: 4
+ *       lock_policy: 'none'  # Docs don't need lock coordination
+ * ```
+ */
+export const LockPolicySchema = z.enum(['all', 'active', 'none']).default('all');
+/**
+ * WU-1345: Lane enforcement configuration schema
+ *
+ * Controls how lane format validation behaves.
+ */
+export const LanesEnforcementSchema = z.object({
+    /**
+     * When true, lanes MUST use "Parent: Sublane" format if parent has taxonomy.
+     * @default true
+     */
+    require_parent: z.boolean().default(true),
+    /**
+     * When false, only lanes in the taxonomy are allowed.
+     * When true, custom lanes can be used.
+     * @default false
+     */
+    allow_custom: z.boolean().default(false),
+});
+/**
+ * WU-1748: Explicit lane lifecycle status for deferred lane process
+ */
+export const LaneLifecycleStatusSchema = z.enum(['unconfigured', 'draft', 'locked']);
+/** WU-1748: Lane lifecycle metadata */
+export const LaneLifecycleSchema = z.object({
+    status: LaneLifecycleStatusSchema,
+    updated_at: z.string().optional(),
+    migrated_at: z.string().optional(),
+    migration_reason: z.string().optional(),
+});
+/**
+ * WU-1322: Lane definition schema for workspace.yaml
+ *
+ * Extends the existing lane configuration with lock_policy field.
+ * Compatible with WU-1016 (wip_limit) and WU-1187 (wip_justification).
+ */
+export const LaneDefinitionSchema = z.object({
+    /** Lane name in "Parent: Sublane" format (e.g., "Framework: Core") */
+    name: z.string(),
+    /** WU-1016: Maximum WUs allowed in progress concurrently for this lane */
+    wip_limit: z.number().int().positive().optional(),
+    /** WU-1187: Required justification when wip_limit > 1 */
+    wip_justification: z.string().optional(),
+    /**
+     * WU-1322: Lock policy for this lane.
+     * - 'all': Lock lane for all other agents (default)
+     * - 'active': Lock only for agents with overlapping code_paths
+     * - 'none': No locking (suitable for documentation lanes)
+     *
+     * @default 'all'
+     *
+     * @example
+     * ```yaml
+     * lanes:
+     *   definitions:
+     *     - name: 'Content: Documentation'
+     *       wip_limit: 4
+     *       lock_policy: 'none'  # Docs can be worked in parallel
+     * ```
+     */
+    lock_policy: LockPolicySchema.default('all'),
+    /** Code paths associated with this lane (glob patterns) */
+    code_paths: z.array(z.string()).optional(),
+});
+/**
+ * WU-1345: Complete lanes configuration schema
+ *
+ * Supports three formats:
+ * 1. definitions array (recommended)
+ * 2. engineering + business arrays (legacy/alternate)
+ * 3. flat array (simple format - parsed as definitions)
+ *
+ * @example
+ * ```yaml
+ * lanes:
+ *   enforcement:
+ *     require_parent: true
+ *     allow_custom: false
+ *   definitions:
+ *     - name: 'Framework: Core'
+ *       wip_limit: 1
+ *       code_paths:
+ *         - 'packages/@lumenflow/core/**'
+ * ```
+ */
+export const LanesConfigSchema = z.object({
+    /** Lane enforcement configuration (validation rules) */
+    enforcement: LanesEnforcementSchema.optional(),
+    /** WU-1748: Deferred lane lifecycle state */
+    lifecycle: LaneLifecycleSchema.optional(),
+    /** Primary lane definitions array (recommended format) */
+    definitions: z.array(LaneDefinitionSchema).optional(),
+    /** Engineering lanes (alternate format) */
+    engineering: z.array(LaneDefinitionSchema).optional(),
+    /** Business lanes (alternate format) */
+    business: z.array(LaneDefinitionSchema).optional(),
+});
+//# sourceMappingURL=lanes-config.js.map

package/dist/schemas/lanes-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes-config.js","sourceRoot":"","sources":["../../src/schemas/lanes-config.ts"],"names":[],"mappings":"AAAA,iCAAiC;AACjC,yCAAyC;AAEzC;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AAKjF;;;;GAIG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C;;;OAGG;IACH,cAAc,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IAEzC;;;;OAIG;IACH,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;CACzC,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;AAErF,uCAAuC;AACvC,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,yBAAyB;IACjC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACxC,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,sEAAsE;IACtE,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAEhB,0EAA0E;IAC1E,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE;IAEjD,yDAAyD;IACzD,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAExC;;;;;;;;;;;;;;;;OAgBG;IACH,WAAW,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC;IAE5C,2DAA2D;IAC3D,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;CAC3C,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,wDAAwD;IACxD,WAAW,EAAE,sBAAsB,CAAC,QAAQ,EAAE;IAE9C,6CAA6C;IAC7C,SAAS,EAAE,mBAAmB,CAAC,QAAQ,EAAE;IAEzC,0DAA0D;IAC1D,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,EAAE;IAErD,2CAA2C;IAC3C,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,EAAE;IAErD,wCAAwC;IACxC,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,EAAE;CACnD,CAAC,CAAC"}

package/dist/schemas/memory-arg-validators.d.ts

@@ -0,0 +1,91 @@
+import type { ValidationResult } from './arg-validators.js';
+/** Validate mem:init arguments */
+export declare const validateMemInitArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu?: string | undefined;
+}>;
+/** Validate mem:start arguments */
+export declare const validateMemStartArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu: string;
+    lane?: string | undefined;
+    agent_type?: string | undefined;
+    context_tier?: string | undefined;
+}>;
+/** Validate mem:ready arguments */
+export declare const validateMemReadyArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu: string;
+    type?: string | undefined;
+    format?: "human" | "json" | undefined;
+}>;
+/** Validate mem:checkpoint arguments */
+export declare const validateMemCheckpointArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu: string;
+    message?: string | undefined;
+    session?: string | undefined;
+    progress?: string | undefined;
+    next_steps?: string | undefined;
+    trigger?: string | undefined;
+}>;
+/** Validate mem:cleanup arguments */
+export declare const validateMemCleanupArgs: (args: Record<string, unknown>) => ValidationResult<{
+    dry_run?: boolean | undefined;
+    ttl?: string | undefined;
+    session_id?: string | undefined;
+}>;
+/** Validate mem:context arguments */
+export declare const validateMemContextArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu: string;
+    lane?: string | undefined;
+    max_size?: number | undefined;
+    max_recent_summaries?: number | undefined;
+    max_project_nodes?: number | undefined;
+    format?: "human" | "json" | undefined;
+}>;
+/** Validate mem:create arguments */
+export declare const validateMemCreateArgs: (args: Record<string, unknown>) => ValidationResult<{
+    message: string;
+    wu?: string | undefined;
+    type?: string | undefined;
+    tags?: string[] | undefined;
+    discovered_from?: string | undefined;
+    session?: string | undefined;
+    priority?: string | undefined;
+}>;
+/** Validate mem:delete arguments */
+export declare const validateMemDeleteArgs: (args: Record<string, unknown>) => ValidationResult<{
+    id: string;
+    tag?: string | undefined;
+    older_than?: string | undefined;
+    dry_run?: boolean | undefined;
+}>;
+/** Validate mem:export arguments */
+export declare const validateMemExportArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu: string;
+    format?: "markdown" | "json" | undefined;
+    type?: string | undefined;
+    lifecycle?: string | undefined;
+}>;
+/** Validate mem:inbox arguments */
+export declare const validateMemInboxArgs: (args: Record<string, unknown>) => ValidationResult<{
+    since?: string | undefined;
+    wu?: string | undefined;
+    lane?: string | undefined;
+}>;
+/** Validate mem:signal arguments */
+export declare const validateMemSignalArgs: (args: Record<string, unknown>) => ValidationResult<{
+    message: string;
+    wu: string;
+}>;
+/** Validate mem:summarize arguments */
+export declare const validateMemSummarizeArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu: string;
+    dry_run?: boolean | undefined;
+}>;
+/** Validate mem:triage arguments */
+export declare const validateMemTriageArgs: (args: Record<string, unknown>) => ValidationResult<{
+    wu?: string | undefined;
+    promote?: string | undefined;
+    lane?: string | undefined;
+    archive?: string | undefined;
+    reason?: string | undefined;
+}>;
+//# sourceMappingURL=memory-arg-validators.d.ts.map

package/dist/schemas/memory-arg-validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-arg-validators.d.ts","sourceRoot":"","sources":["../../src/schemas/memory-arg-validators.ts"],"names":[],"mappings":"AAyCA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AA4E5D,kCAAkC;AAClC,eAAO,MAAM,mBAAmB,SA3BrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;EA2B6C,CAAC;AAEhF,mCAAmC;AACnC,eAAO,MAAM,oBAAoB,SA9BtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;EA8BgD,CAAC;AAEnF,mCAAmC;AACnC,eAAO,MAAM,oBAAoB,SAjCtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;EAiCgD,CAAC;AAEnF,wCAAwC;AACxC,eAAO,MAAM,yBAAyB,SApC3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;EAoC+D,CAAC;AAElG,qCAAqC;AACrC,eAAO,MAAM,sBAAsB,SAvCxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;EAuCsD,CAAC;AAEzF,qCAAqC;AACrC,eAAO,MAAM,sBAAsB,SA1CxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;EA0CsD,CAAC;AAEzF,oCAAoC;AACpC,eAAO,MAAM,qBAAqB,SA7CvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;EA6CmD,CAAC;AAEtF,oCAAoC;AACpC,eAAO,MAAM,qBAAqB,SAhDvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;EAgDmD,CAAC;AAEtF,oCAAoC;AACpC,eAAO,MAAM,qBAAqB,SAnDvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;EAmDmD,CAAC;AAEtF,mCAAmC;AACnC,eAAO,MAAM,oBAAoB,SAtDtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;EAsDgD,CAAC;AAEnF,oCAAoC;AACpC,eAAO,MAAM,qBAAqB,SAzDvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;EAyDmD,CAAC;AAEtF,uCAAuC;AACvC,eAAO,MAAM,wBAAwB,SA5D1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;EA4D4D,CAAC;AAE/F,oCAAoC;AACpC,eAAO,MAAM,qBAAqB,SA/DvB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;EA+DmD,CAAC"}

package/dist/schemas/memory-arg-validators.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * @file memory-arg-validators.ts
+ * @description CLI argument validators for memory commands using shared schemas (WU-1456)
+ *
+ * These validators use the shared Zod schemas to validate CLI arguments for the
+ * 13 memory commands. They follow the same pattern as initiative-arg-validators.ts
+ * (WU-1455).
+ */
+import { memInitSchema, memStartSchema, memReadySchema, memCheckpointSchema, memCleanupSchema, memContextSchema, memCreateSchema, memDeleteSchema, memExportSchema, memInboxSchema, memSignalSchema, memSummarizeSchema, memTriageSchema, } from './memory-schemas.js';
+function formatZodErrors(error) {
+    return error.issues.map((issue) => {
+        const path = issue.path.filter((p) => typeof p !== 'symbol').join('.');
+        if (issue.code === 'invalid_type' && issue.message.includes('received undefined')) {
+            return `${path} is required`;
+        }
+        if (issue.message === 'Required') {
+            return `${path} is required`;
+        }
+        return `${path}: ${issue.message}`;
+    });
+}
+/**
+ * Create a validator function from a Zod schema
+ */
+function createValidator(schema) {
+    return (args) => {
+        const result = schema.safeParse(args);
+        if (result.success && result.data !== undefined) {
+            return {
+                valid: true,
+                errors: [],
+                warnings: [],
+                normalized: result.data,
+            };
+        }
+        return {
+            valid: false,
+            errors: result.error ? formatZodErrors(result.error) : ['Validation failed'],
+            warnings: [],
+            normalized: args,
+        };
+    };
+}
+// =============================================================================
+// Validators
+// =============================================================================
+/** Validate mem:init arguments */
+export const validateMemInitArgs = createValidator(memInitSchema);
+/** Validate mem:start arguments */
+export const validateMemStartArgs = createValidator(memStartSchema);
+/** Validate mem:ready arguments */
+export const validateMemReadyArgs = createValidator(memReadySchema);
+/** Validate mem:checkpoint arguments */
+export const validateMemCheckpointArgs = createValidator(memCheckpointSchema);
+/** Validate mem:cleanup arguments */
+export const validateMemCleanupArgs = createValidator(memCleanupSchema);
+/** Validate mem:context arguments */
+export const validateMemContextArgs = createValidator(memContextSchema);
+/** Validate mem:create arguments */
+export const validateMemCreateArgs = createValidator(memCreateSchema);
+/** Validate mem:delete arguments */
+export const validateMemDeleteArgs = createValidator(memDeleteSchema);
+/** Validate mem:export arguments */
+export const validateMemExportArgs = createValidator(memExportSchema);
+/** Validate mem:inbox arguments */
+export const validateMemInboxArgs = createValidator(memInboxSchema);
+/** Validate mem:signal arguments */
+export const validateMemSignalArgs = createValidator(memSignalSchema);
+/** Validate mem:summarize arguments */
+export const validateMemSummarizeArgs = createValidator(memSummarizeSchema);
+/** Validate mem:triage arguments */
+export const validateMemTriageArgs = createValidator(memTriageSchema);
+//# sourceMappingURL=memory-arg-validators.js.map

package/dist/schemas/memory-arg-validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-arg-validators.js","sourceRoot":"","sources":["../../src/schemas/memory-arg-validators.ts"],"names":[],"mappings":"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"}

package/dist/schemas/memory-config.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Memory Layer Configuration Schemas
+ *
+ * Memory, progress signals, signal cleanup, auto-checkpoint, enforcement,
+ * and decay policy schemas.
+ *
+ * @module schemas/memory-config
+ */
+import { z } from 'zod';
+/**
+ * WU-1203: Progress signals configuration for sub-agent coordination
+ *
+ * When enabled, spawn prompts will include mandatory progress signal directives
+ * at configurable triggers (milestone completion, tests pass, before gates, when blocked).
+ * Frequency-based signals (every N tool calls) also supported.
+ *
+ * Addresses sub-agent coordination needs without unnecessary token waste.
+ */
+export declare const ProgressSignalsConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    frequency: z.ZodDefault<z.ZodNumber>;
+    on_milestone: z.ZodDefault<z.ZodBoolean>;
+    on_tests_pass: z.ZodDefault<z.ZodBoolean>;
+    before_gates: z.ZodDefault<z.ZodBoolean>;
+    on_blocked: z.ZodDefault<z.ZodBoolean>;
+    auto_checkpoint: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Signal cleanup configuration (WU-1204)
+ *
+ * Configures TTL-based cleanup for signals in .lumenflow/memory/signals.jsonl
+ * to prevent unbounded growth.
+ */
+export declare const SignalCleanupConfigSchema: z.ZodObject<{
+    ttl: z.ZodDefault<z.ZodNumber>;
+    unreadTtl: z.ZodDefault<z.ZodNumber>;
+    maxEntries: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * WU-1471: Auto-checkpoint configuration
+ *
+ * Controls automatic checkpointing behavior via Claude Code hooks.
+ * When enabled and hooks are active, PostToolUse and SubagentStop hooks
+ * create checkpoints at configurable intervals.
+ *
+ * @example
+ * ```yaml
+ * memory:
+ *   enforcement:
+ *     auto_checkpoint:
+ *       enabled: true
+ *       interval_tool_calls: 30
+ * ```
+ */
+export declare const AutoCheckpointConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    interval_tool_calls: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/** WU-1471: TypeScript type for auto-checkpoint config */
+export type AutoCheckpointConfig = z.infer<typeof AutoCheckpointConfigSchema>;
+/**
+ * WU-1471: Memory enforcement configuration
+ *
+ * Controls enforcement of memory layer practices:
+ * - Auto-checkpointing via hooks
+ * - Checkpoint gate on wu:done
+ *
+ * @example
+ * ```yaml
+ * memory:
+ *   enforcement:
+ *     auto_checkpoint:
+ *       enabled: true
+ *       interval_tool_calls: 30
+ *     require_checkpoint_for_done: warn
+ * ```
+ */
+export declare const MemoryEnforcementConfigSchema: z.ZodObject<{
+    auto_checkpoint: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        interval_tool_calls: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    require_checkpoint_for_done: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        warn: "warn";
+        block: "block";
+    }>>;
+}, z.core.$strip>;
+/** WU-1471: TypeScript type for memory enforcement config */
+export type MemoryEnforcementConfig = z.infer<typeof MemoryEnforcementConfigSchema>;
+/**
+ * WU-1474: Memory decay policy configuration
+ *
+ * Controls automated archival of stale memory nodes during lifecycle events.
+ * When enabled with trigger=on_done, wu:done will invoke decay archival
+ * using the configured threshold and half-life parameters.
+ *
+ * Fail-open: archival errors never block wu:done completion.
+ *
+ * @example
+ * ```yaml
+ * memory:
+ *   decay:
+ *     enabled: true
+ *     threshold: 0.1
+ *     half_life_days: 30
+ *     trigger: on_done
+ * ```
+ */
+export declare const MemoryDecayConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    threshold: z.ZodDefault<z.ZodNumber>;
+    half_life_days: z.ZodDefault<z.ZodNumber>;
+    trigger: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        on_done: "on_done";
+    }>>;
+}, z.core.$strip>;
+/** WU-1474: TypeScript type for memory decay config */
+export type MemoryDecayConfig = z.infer<typeof MemoryDecayConfigSchema>;
+/**
+ * Memory layer configuration
+ */
+export declare const MemoryConfigSchema: z.ZodObject<{
+    directory: z.ZodDefault<z.ZodString>;
+    sessionTtl: z.ZodDefault<z.ZodNumber>;
+    checkpointTtl: z.ZodDefault<z.ZodNumber>;
+    enableAutoCleanup: z.ZodDefault<z.ZodBoolean>;
+    progress_signals: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        frequency: z.ZodDefault<z.ZodNumber>;
+        on_milestone: z.ZodDefault<z.ZodBoolean>;
+        on_tests_pass: z.ZodDefault<z.ZodBoolean>;
+        before_gates: z.ZodDefault<z.ZodBoolean>;
+        on_blocked: z.ZodDefault<z.ZodBoolean>;
+        auto_checkpoint: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    signalCleanup: z.ZodDefault<z.ZodObject<{
+        ttl: z.ZodDefault<z.ZodNumber>;
+        unreadTtl: z.ZodDefault<z.ZodNumber>;
+        maxEntries: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    delegation_context_max_size: z.ZodDefault<z.ZodNumber>;
+    spawn_context_max_size: z.ZodOptional<z.ZodUnknown> & z.ZodType<undefined, unknown, z.core.$ZodTypeInternals<undefined, unknown>>;
+    enforcement: z.ZodOptional<z.ZodObject<{
+        auto_checkpoint: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            interval_tool_calls: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        require_checkpoint_for_done: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            warn: "warn";
+            block: "block";
+        }>>;
+    }, z.core.$strip>>;
+    decay: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        threshold: z.ZodDefault<z.ZodNumber>;
+        half_life_days: z.ZodDefault<z.ZodNumber>;
+        trigger: z.ZodDefault<z.ZodEnum<{
+            manual: "manual";
+            on_done: "on_done";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProgressSignalsConfig = z.infer<typeof ProgressSignalsConfigSchema>;
+export type SignalCleanupConfig = z.infer<typeof SignalCleanupConfigSchema>;
+export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
+//# sourceMappingURL=memory-config.d.ts.map

package/dist/schemas/memory-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-config.d.ts","sourceRoot":"","sources":["../../src/schemas/memory-config.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;iBA6CtC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;;iBAmBpC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B;;;iBAgBrC,CAAC;AAEH,0DAA0D;AAC1D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;iBAexC,CAAC;AAEH,6DAA6D;AAC7D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;iBA+BlC,CAAC;AAEH,uDAAuD;AACvD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAOxE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyD7B,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}