@lumenflow/core 2.2.2 → 2.3.1

package/dist/lane-suggest-prompt.js

@@ -0,0 +1,359 @@
+/**
+ * Lane Suggestion Prompt Module (WU-1189)
+ *
+ * Generates prompts for LLM-driven lane suggestions based on codebase context.
+ * This module gathers project context and generates structured prompts for
+ * the LLM to analyze and suggest appropriate lane definitions.
+ *
+ * Design decisions:
+ * - Uses LLM for semantic understanding (not hardcoded heuristics)
+ * - Gathers context from docs, structure, and existing config
+ * - Returns structured JSON for easy parsing
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import { z } from 'zod';
+/**
+ * Schema for a single lane suggestion from the LLM
+ */
+export const LaneSuggestionSchema = z.object({
+    lane: z.string().describe('Lane name in "Parent: Sublane" format'),
+    description: z.string().describe('Brief description of what this lane covers'),
+    rationale: z.string().describe('Why this lane was suggested based on the codebase'),
+    code_paths: z.array(z.string()).describe('Glob patterns for files in this lane'),
+    keywords: z.array(z.string()).describe('Keywords that indicate work belongs to this lane'),
+});
+/**
+ * Schema for the complete LLM response
+ */
+export const LaneSuggestResponseSchema = z.object({
+    suggestions: z.array(LaneSuggestionSchema),
+});
+/**
+ * Read directory structure from project root
+ */
+function readDirectoryStructure(projectRoot) {
+    try {
+        const entries = readdirSync(projectRoot, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name)
+            .filter((name) => !name.startsWith('.') && name !== 'node_modules');
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read README.md content
+ */
+function readReadme(projectRoot) {
+    const readmePath = path.join(projectRoot, 'README.md');
+    if (!existsSync(readmePath))
+        return null;
+    try {
+        return readFileSync(readmePath, 'utf-8').slice(0, 2000);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Read package.json and detect monorepo
+ */
+function readPackageJson(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+        return { packageJson: null, isMonorepo: false };
+    }
+    try {
+        const content = readFileSync(packageJsonPath, 'utf-8');
+        const pkg = JSON.parse(content);
+        const hasWorkspaces = !!pkg.workspaces;
+        const hasPnpmWorkspace = existsSync(path.join(projectRoot, 'pnpm-workspace.yaml'));
+        return {
+            packageJson: {
+                name: pkg.name,
+                description: pkg.description,
+                workspaces: pkg.workspaces,
+            },
+            isMonorepo: hasWorkspaces || hasPnpmWorkspace,
+        };
+    }
+    catch {
+        return { packageJson: null, isMonorepo: false };
+    }
+}
+/**
+ * Gather package names from packages/ directory
+ */
+function gatherPackageNames(projectRoot) {
+    const packagesDir = path.join(projectRoot, 'packages');
+    if (!existsSync(packagesDir))
+        return [];
+    try {
+        const packageDirs = readdirSync(packagesDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+        const names = [];
+        for (const pkgDir of packageDirs) {
+            const pkgPath = path.join(packagesDir, pkgDir);
+            if (pkgDir.startsWith('@')) {
+                // Scoped packages
+                const scopePackages = readdirSync(pkgPath, { withFileTypes: true })
+                    .filter((e) => e.isDirectory())
+                    .map((e) => `${pkgDir}/${e.name}`);
+                names.push(...scopePackages);
+            }
+            else if (existsSync(path.join(pkgPath, 'package.json'))) {
+                names.push(pkgDir);
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Read existing lane configuration
+ */
+function readExistingLanes(projectRoot) {
+    const laneConfigPath = path.join(projectRoot, '.lumenflow.lane-inference.yaml');
+    if (!existsSync(laneConfigPath))
+        return [];
+    try {
+        const content = readFileSync(laneConfigPath, 'utf-8');
+        const config = YAML.parse(content);
+        const lanes = [];
+        for (const [parent, sublanes] of Object.entries(config)) {
+            if (typeof sublanes === 'object' && sublanes !== null) {
+                for (const sublane of Object.keys(sublanes)) {
+                    lanes.push(`${parent}: ${sublane}`);
+                }
+            }
+        }
+        return lanes;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Gather project context from the filesystem
+ */
+export function gatherProjectContext(projectRoot) {
+    const directoryStructure = readDirectoryStructure(projectRoot);
+    const { packageJson, isMonorepo: isMonorepoPkg } = readPackageJson(projectRoot);
+    const hasPnpmWorkspace = existsSync(path.join(projectRoot, 'pnpm-workspace.yaml'));
+    const hasPackagesDir = directoryStructure.includes('packages');
+    return {
+        directoryStructure,
+        hasDocsDir: directoryStructure.includes('docs'),
+        hasAppsDir: directoryStructure.includes('apps'),
+        hasPackagesDir,
+        readme: readReadme(projectRoot),
+        packageJson,
+        isMonorepo: isMonorepoPkg || hasPnpmWorkspace,
+        packageNames: hasPackagesDir ? gatherPackageNames(projectRoot) : [],
+        existingLanes: readExistingLanes(projectRoot),
+    };
+}
+/**
+ * Generate the system prompt for lane suggestion
+ */
+export function generateSystemPrompt() {
+    return `You are an expert software architect helping configure a LumenFlow workflow project.
+
+LumenFlow uses "lanes" to organize work. Each lane has:
+- A name in "Parent: Sublane" format (e.g., "Framework: Core", "Operations: CI/CD")
+- code_paths: Glob patterns for files that belong to this lane
+- keywords: Terms that indicate work belongs to this lane
+- description: Brief explanation of what the lane covers
+
+Lane naming conventions:
+- Parent categories: Framework, Operations, Content, Experience, Intelligence, Quality
+- Sublane names should be specific and descriptive
+- Use "/" for sublanes that are further subdivisions (e.g., "Operations: CI/CD")
+
+Your task is to analyze the provided project context and suggest appropriate lane definitions.
+
+Respond with a JSON object containing an array of lane suggestions. Each suggestion must include:
+- lane: The lane name in "Parent: Sublane" format
+- description: Brief description of what this lane covers
+- rationale: Why you're suggesting this lane based on the project structure
+- code_paths: Array of glob patterns for files in this lane
+- keywords: Array of keywords that indicate work belongs to this lane
+
+Example response:
+{
+  "suggestions": [
+    {
+      "lane": "Framework: Core",
+      "description": "Core library with shared utilities and base functionality",
+      "rationale": "Found packages/core with TypeScript source files and utility modules",
+      "code_paths": ["packages/core/**"],
+      "keywords": ["core", "utilities", "shared", "base"]
+    }
+  ]
+}`;
+}
+/**
+ * Generate the user prompt with project context
+ */
+export function generateUserPrompt(context) {
+    const sections = [];
+    sections.push('# Project Analysis Request\n');
+    sections.push('Please analyze this project structure and suggest appropriate LumenFlow lanes.\n');
+    // Project type
+    sections.push(`## Project Type`);
+    sections.push(`- Monorepo: ${context.isMonorepo ? 'Yes' : 'No'}`);
+    sections.push(`- Has packages/: ${context.hasPackagesDir ? 'Yes' : 'No'}`);
+    sections.push(`- Has apps/: ${context.hasAppsDir ? 'Yes' : 'No'}`);
+    sections.push(`- Has docs/: ${context.hasDocsDir ? 'Yes' : 'No'}`);
+    sections.push('');
+    // Directory structure
+    if (context.directoryStructure.length > 0) {
+        sections.push('## Top-Level Directories');
+        sections.push(context.directoryStructure.map((d) => `- ${d}/`).join('\n'));
+        sections.push('');
+    }
+    // Package names
+    if (context.packageNames.length > 0) {
+        sections.push('## Packages Found');
+        sections.push(context.packageNames.map((p) => `- ${p}`).join('\n'));
+        sections.push('');
+    }
+    // Package.json info
+    if (context.packageJson) {
+        sections.push('## Package Info');
+        if (context.packageJson.name) {
+            sections.push(`- Name: ${context.packageJson.name}`);
+        }
+        if (context.packageJson.description) {
+            sections.push(`- Description: ${context.packageJson.description}`);
+        }
+        sections.push('');
+    }
+    // README excerpt
+    if (context.readme) {
+        sections.push('## README Excerpt');
+        sections.push('```');
+        sections.push(context.readme.slice(0, 1000));
+        sections.push('```');
+        sections.push('');
+    }
+    // Existing lanes
+    if (context.existingLanes.length > 0) {
+        sections.push('## Existing Lanes (for reference)');
+        sections.push('The project already has these lanes configured:');
+        sections.push(context.existingLanes.map((l) => `- ${l}`).join('\n'));
+        sections.push('');
+        sections.push('Consider these when making suggestions to maintain consistency.');
+        sections.push('');
+    }
+    sections.push('## Instructions');
+    sections.push('Based on this context, suggest lanes that would help organize work on this project.');
+    sections.push('Consider:');
+    sections.push('- The types of packages/modules present');
+    sections.push('- Common development patterns for this project type');
+    sections.push('- Standard lanes for documentation, CI/CD, and operations');
+    sections.push('');
+    sections.push('Respond with JSON only, no markdown code fences or explanation.');
+    return sections.join('\n');
+}
+/**
+ * Parse and validate LLM response
+ */
+export function parseLLMResponse(response) {
+    // Try to extract JSON from response (LLMs sometimes add markdown code fences)
+    let jsonStr = response.trim();
+    // Remove markdown code fences if present
+    if (jsonStr.startsWith('```json')) {
+        jsonStr = jsonStr.slice(7);
+    }
+    else if (jsonStr.startsWith('```')) {
+        jsonStr = jsonStr.slice(3);
+    }
+    if (jsonStr.endsWith('```')) {
+        jsonStr = jsonStr.slice(0, -3);
+    }
+    jsonStr = jsonStr.trim();
+    // Parse JSON
+    const parsed = JSON.parse(jsonStr);
+    // Validate with schema
+    return LaneSuggestResponseSchema.parse(parsed);
+}
+/**
+ * Validate that a lane name follows the "Parent: Sublane" format
+ */
+export function isValidLaneFormat(lane) {
+    // Format: "Parent: Sublane" where both start with uppercase
+    return /^[A-Z][a-zA-Z]+: [A-Z][a-zA-Z/]+$/.test(lane);
+}
+/**
+ * Generate a dry-run preview of what would be sent to the LLM
+ */
+export function generateDryRunPreview(projectRoot) {
+    const context = gatherProjectContext(projectRoot);
+    const systemPrompt = generateSystemPrompt();
+    const userPrompt = generateUserPrompt(context);
+    return {
+        context,
+        systemPrompt,
+        userPrompt,
+    };
+}
+/**
+ * Get default lane suggestions for a minimal project
+ * Used when LLM is not available or for dry-run
+ */
+export function getDefaultSuggestions(context) {
+    const suggestions = [];
+    // Always suggest documentation lane if docs exist
+    if (context.hasDocsDir) {
+        suggestions.push({
+            lane: 'Content: Documentation',
+            description: 'Project documentation and guides',
+            rationale: 'Found docs/ directory',
+            code_paths: ['docs/**', 'README.md', '*.md'],
+            keywords: ['docs', 'documentation', 'readme', 'guide'],
+        });
+    }
+    // Suggest operations lane for CI/CD
+    if (context.directoryStructure.some((d) => d === '.github' || d === '.gitlab-ci')) {
+        suggestions.push({
+            lane: 'Operations: CI/CD',
+            description: 'Continuous integration and deployment',
+            rationale: 'Found CI/CD configuration directory',
+            code_paths: ['.github/**', '.gitlab-ci.yml'],
+            keywords: ['ci', 'cd', 'workflow', 'pipeline', 'actions'],
+        });
+    }
+    // For monorepos, suggest lanes based on package names
+    if (context.isMonorepo && context.packageNames.length > 0) {
+        for (const pkg of context.packageNames) {
+            const pkgName = pkg.split('/').pop() || pkg;
+            const capitalizedName = pkgName.charAt(0).toUpperCase() + pkgName.slice(1);
+            suggestions.push({
+                lane: `Framework: ${capitalizedName}`,
+                description: `${capitalizedName} package functionality`,
+                rationale: `Found package: ${pkg}`,
+                code_paths: [`packages/${pkg}/**`],
+                keywords: [pkgName.toLowerCase()],
+            });
+        }
+    }
+    // Fallback: suggest a core development lane
+    if (suggestions.length === 0) {
+        suggestions.push({
+            lane: 'Development: Core',
+            description: 'Main application code',
+            rationale: 'Default lane for project source code',
+            code_paths: ['src/**', 'lib/**'],
+            keywords: ['source', 'core', 'main'],
+        });
+    }
+    return suggestions;
+}

package/dist/lane-validator.d.ts

@@ -5,13 +5,13 @@
  * Validates that a WU's code_paths are consistent with its assigned lane.
  * This is an advisory validation - it warns but never blocks wu:claim or wu:done.
  *
- * Uses LANE_PATH_PATTERNS from wu-constants.mjs to define which paths
+ * Uses LANE_PATH_PATTERNS from wu-constants.ts to define which paths
  * are discouraged for each lane parent.
  *
  * Part of INIT-002: Workflow Integrity initiative.
  *
- * @see {@link wu-constants.mjs} - LANE_PATH_PATTERNS definition
- * @see {@link lane-checker.mjs} - extractParent for lane parsing
+ * @see {@link wu-constants.ts} - LANE_PATH_PATTERNS definition
+ * @see {@link lane-checker.ts} - extractParent for lane parsing
  */
 /**
  * @typedef {object} LaneValidationResult

package/dist/lane-validator.js

@@ -5,13 +5,13 @@
  * Validates that a WU's code_paths are consistent with its assigned lane.
  * This is an advisory validation - it warns but never blocks wu:claim or wu:done.
  *
- * Uses LANE_PATH_PATTERNS from wu-constants.mjs to define which paths
+ * Uses LANE_PATH_PATTERNS from wu-constants.ts to define which paths
  * are discouraged for each lane parent.
  *
  * Part of INIT-002: Workflow Integrity initiative.
  *
- * @see {@link wu-constants.mjs} - LANE_PATH_PATTERNS definition
- * @see {@link lane-checker.mjs} - extractParent for lane parsing
+ * @see {@link wu-constants.ts} - LANE_PATH_PATTERNS definition
+ * @see {@link lane-checker.ts} - extractParent for lane parsing
  */
 import micromatch from 'micromatch';
 import { extractParent } from './lane-checker.js';

package/dist/logs-lib.d.ts

@@ -10,7 +10,7 @@
  *
  * LIBRARY-FIRST: No general-purpose library exists for project-specific log
  * aggregation across custom log locations. Uses native JSON.parse like existing
- * tail-logs.mjs in the codebase.
+ * tail-logs.ts in the codebase.
  *
  * @see docs/02-technical/standards/logging.md
  */

package/dist/logs-lib.js

@@ -10,7 +10,7 @@
  *
  * LIBRARY-FIRST: No general-purpose library exists for project-specific log
  * aggregation across custom log locations. Uses native JSON.parse like existing
- * tail-logs.mjs in the codebase.
+ * tail-logs.ts in the codebase.
  *
  * @see docs/02-technical/standards/logging.md
  */

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

@@ -7,6 +7,16 @@
  * @module lumenflow-config-schema
  */
 import { z } from 'zod';
+/**
+ * Event archival configuration (WU-1207)
+ *
+ * Configures archival of old WU events from .lumenflow/state/wu-events.jsonl
+ * to .lumenflow/archive/wu-events-YYYY-MM.jsonl to prevent unbounded growth.
+ */
+export declare const EventArchivalConfigSchema: z.ZodObject<{
+    archiveAfter: z.ZodDefault<z.ZodNumber>;
+    keepArchives: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
 /**
  * Directory paths configuration
  */
@@ -32,6 +42,7 @@ export declare const DirectoriesSchema: z.ZodObject<{
 export declare const BeaconPathsSchema: z.ZodObject<{
     base: z.ZodDefault<z.ZodString>;
     stateDir: z.ZodDefault<z.ZodString>;
+    archiveDir: z.ZodDefault<z.ZodString>;
     stampsDir: z.ZodDefault<z.ZodString>;
     mergeLock: z.ZodDefault<z.ZodString>;
     telemetry: z.ZodDefault<z.ZodString>;
@@ -39,6 +50,10 @@ export declare const BeaconPathsSchema: z.ZodObject<{
     sessions: z.ZodDefault<z.ZodString>;
     incidents: z.ZodDefault<z.ZodString>;
     commandsLog: z.ZodDefault<z.ZodString>;
+    eventArchival: z.ZodDefault<z.ZodObject<{
+        archiveAfter: z.ZodDefault<z.ZodNumber>;
+        keepArchives: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Git configuration
@@ -110,6 +125,35 @@ export declare const GatesConfigSchema: z.ZodObject<{
         }, z.core.$strip>]>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+/**
+ * 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>;
 /**
  * Memory layer configuration
  */
@@ -118,6 +162,21 @@ export declare const MemoryConfigSchema: z.ZodObject<{
     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>>;
+    spawn_context_max_size: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 /**
  * UI configuration
@@ -231,6 +290,25 @@ export declare const ExperimentalConfigSchema: z.ZodObject<{
     show_next_steps: z.ZodDefault<z.ZodBoolean>;
     recovery_command: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
+/**
+ * WU-1270: Methodology telemetry configuration
+ *
+ * Opt-in telemetry to track which methodology modes are being used.
+ * Privacy-preserving: No PII or project-identifying information collected.
+ */
+export declare const MethodologyTelemetryConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * WU-1270: Telemetry configuration
+ *
+ * Configuration for opt-in telemetry features.
+ */
+export declare const TelemetryConfigSchema: z.ZodObject<{
+    methodology: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 /**
  * Complete LumenFlow configuration schema
  */
@@ -255,6 +333,7 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
     beacon: z.ZodDefault<z.ZodObject<{
         base: z.ZodDefault<z.ZodString>;
         stateDir: z.ZodDefault<z.ZodString>;
+        archiveDir: z.ZodDefault<z.ZodString>;
         stampsDir: z.ZodDefault<z.ZodString>;
         mergeLock: z.ZodDefault<z.ZodString>;
         telemetry: z.ZodDefault<z.ZodString>;
@@ -262,6 +341,10 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
         sessions: z.ZodDefault<z.ZodString>;
         incidents: z.ZodDefault<z.ZodString>;
         commandsLog: z.ZodDefault<z.ZodString>;
+        eventArchival: z.ZodDefault<z.ZodObject<{
+            archiveAfter: z.ZodDefault<z.ZodNumber>;
+            keepArchives: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     git: z.ZodDefault<z.ZodObject<{
         mainBranch: z.ZodDefault<z.ZodString>;
@@ -328,6 +411,21 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
         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>>;
+        spawn_context_max_size: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     ui: z.ZodDefault<z.ZodObject<{
         errorBoxWidth: z.ZodDefault<z.ZodNumber>;
@@ -372,6 +470,31 @@ export declare const LumenFlowConfigSchema: z.ZodObject<{
         show_next_steps: z.ZodDefault<z.ZodBoolean>;
         recovery_command: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    telemetry: z.ZodDefault<z.ZodObject<{
+        methodology: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    methodology: z.ZodOptional<z.ZodObject<{
+        testing: z.ZodDefault<z.ZodEnum<{
+            tdd: "tdd";
+            "test-after": "test-after";
+            none: "none";
+        }>>;
+        architecture: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            hexagonal: "hexagonal";
+            layered: "layered";
+        }>>;
+        overrides: z.ZodOptional<z.ZodObject<{
+            coverage_threshold: z.ZodOptional<z.ZodNumber>;
+            coverage_mode: z.ZodOptional<z.ZodEnum<{
+                off: "off";
+                warn: "warn";
+                block: "block";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * TypeScript types inferred from schemas
@@ -381,6 +504,9 @@ export type BeaconPaths = z.infer<typeof BeaconPathsSchema>;
 export type GitConfig = z.infer<typeof GitConfigSchema>;
 export type WuConfig = z.infer<typeof WuConfigSchema>;
 export type GatesConfig = z.infer<typeof GatesConfigSchema>;
+export type ProgressSignalsConfig = z.infer<typeof ProgressSignalsConfigSchema>;
+export type SignalCleanupConfig = z.infer<typeof SignalCleanupConfigSchema>;
+export type EventArchivalConfig = z.infer<typeof EventArchivalConfigSchema>;
 export type MemoryConfig = z.infer<typeof MemoryConfigSchema>;
 export type UiConfig = z.infer<typeof UiConfigSchema>;
 export type YamlConfig = z.infer<typeof YamlConfigSchema>;
@@ -391,7 +517,10 @@ export type ClientConfig = z.infer<typeof ClientConfigSchema>;
 export type AgentsConfig = z.infer<typeof AgentsConfigSchema>;
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;
 export type ValidationMode = z.infer<typeof ValidationModeSchema>;
+export type MethodologyTelemetryConfig = z.infer<typeof MethodologyTelemetryConfigSchema>;
+export type TelemetryConfig = z.infer<typeof TelemetryConfigSchema>;
 export type LumenFlowConfig = z.infer<typeof LumenFlowConfigSchema>;
+export type { MethodologyConfig, MethodologyOverrides } from './resolve-policy.js';
 /**
  * Validate configuration data
  *
@@ -419,6 +548,7 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
     beacon: {
         base: string;
         stateDir: string;
+        archiveDir: string;
         stampsDir: string;
         mergeLock: string;
         telemetry: string;
@@ -426,6 +556,10 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
         sessions: string;
         incidents: string;
         commandsLog: string;
+        eventArchival: {
+            archiveAfter: number;
+            keepArchives: boolean;
+        };
     };
     git: {
         mainBranch: string;
@@ -492,6 +626,21 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
         sessionTtl: number;
         checkpointTtl: number;
         enableAutoCleanup: boolean;
+        signalCleanup: {
+            ttl: number;
+            unreadTtl: number;
+            maxEntries: number;
+        };
+        spawn_context_max_size: number;
+        progress_signals?: {
+            enabled: boolean;
+            frequency: number;
+            on_milestone: boolean;
+            on_tests_pass: boolean;
+            before_gates: boolean;
+            on_blocked: boolean;
+            auto_checkpoint: boolean;
+        };
     };
     ui: {
         errorBoxWidth: number;
@@ -529,6 +678,19 @@ export declare function validateConfig(data: unknown): z.ZodSafeParseResult<{
         show_next_steps: boolean;
         recovery_command: boolean;
     };
+    telemetry: {
+        methodology: {
+            enabled: boolean;
+        };
+    };
+    methodology?: {
+        testing: "tdd" | "test-after" | "none";
+        architecture: "none" | "hexagonal" | "layered";
+        overrides?: {
+            coverage_threshold?: number;
+            coverage_mode?: "off" | "warn" | "block";
+        };
+    };
 }>;
 /**
  * Parse configuration with defaults