strray-ai 1.22.68 → 1.22.69

package/dist/cli/commands/hermes-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerHermesCommands(hermesCmd: Command): void;

package/dist/cli/commands/mcp-install.d.ts

@@ -0,0 +1,4 @@
+export declare function listMCPsCommand(): void;
+export declare function showMCPStatusCommand(): void;
+export declare function installMCPCommand(name: string): Promise<void>;
+export declare function removeMCPCommand(name: string): void;

package/dist/cli/commands/openclaw-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpenClawCommands(openclawCmd: Command): void;

package/dist/cli/commands/opencode-install.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerOpencodeCommands(opencodeCmd: Command): void;

package/dist/cli/commands/plugin-commands.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Plugin CLI Commands
+ *
+ * CLI commands for plugin management:
+ * - plugin list
+ * - plugin install (from npm or local)
+ * - plugin enable
+ * - plugin disable
+ * - plugin status
+ * - plugin uninstall
+ *
+ * @version 1.1.0
+ */
+export declare function pluginListCommand(): Promise<void>;
+export declare function pluginInstallCommand(pluginName: string): Promise<void>;
+export declare function pluginEnableCommand(pluginName: string): Promise<void>;
+export declare function pluginDisableCommand(pluginName: string): Promise<void>;
+export declare function pluginStatusCommand(pluginName: string): Promise<void>;
+export declare function pluginUninstallCommand(pluginName: string): Promise<void>;

package/dist/cli/commands/publish-agent.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Publish Agent CLI Command
+ *
+ * Packages and publishes agents to AgentStore for sharing.
+ *
+ * Usage: npx strray-ai publish-agent [options]
+ * Options:
+ *   --agent <name>    Agent name to publish (required)
+ *   --version <ver>   Version (optional, auto-detected)
+ *   --dry-run         Preview package without publishing
+ *
+ * Example: npx strray-ai publish-agent --agent orchestrator --dry-run
+ */
+export declare function publishAgentCommand(): Promise<void>;
+export default publishAgentCommand;

package/dist/cli/commands/security-audit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Security Audit CLI Command
+ *
+ * Comprehensive security audit with vulnerability scanning,
+ * compliance checking, and weighted voting for architectural decisions.
+ *
+ * Usage:
+ *   npx strray-ai security-audit           # Quick audit
+ *   npx strray-ai security-audit --deep    # Deep audit with all standards
+ *   npx strray-ai security-audit --output ./reports/security.md
+ *   npx strray-ai security-audit --no-remediation
+ *   npx strray-ai security-audit --no-voting
+ *
+ * Options:
+ *   --deep           Deep scan with all compliance standards (OWASP, CWE, NIST, ISO, PCI)
+ *   --output <path>  Output report to file (JSON or Markdown)
+ *   --format <fmt>   Output format: json, markdown (default: markdown)
+ *   --no-remediation Skip automated remediation analysis
+ *   --no-voting      Disable weighted voting for architectural decisions
+ *   --project <path> Project path to audit (default: current directory)
+ */
+export declare function securityAuditCommand(args?: string[]): Promise<void>;
+export default securityAuditCommand;

package/dist/cli/commands/skill-install.d.ts

@@ -0,0 +1,5 @@
+export declare function skillInstallCommand(sourceArg?: string, options?: {
+    force?: boolean;
+    path?: string;
+}): Promise<void>;
+export declare function skillRegistryCommand(action?: string, args?: Record<string, string>): Promise<void>;

package/dist/cli/commands/status.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Status CLI Command
+ *
+ * Shows comprehensive framework status including:
+ * - OpenCode installation status
+ * - Installed skills
+ * - Configured agents
+ * - Health metrics
+ * - Inference engine status
+ *
+ * Usage: npx strray-ai status
+ */
+interface StatusReport {
+    opencode: {
+        installed: boolean;
+        configFound: boolean;
+    };
+    skills: {
+        count: number;
+        names: string[];
+    };
+    agents: {
+        count: number;
+        names: string[];
+    };
+    health: {
+        logPath: string;
+        logExists: boolean;
+        recentEntries: number;
+    };
+    inference: {
+        active: boolean;
+        lastTuning: string | null;
+        outcomesCount: number;
+        patternsCount: number;
+    };
+}
+export declare function getStatusReport(cwd?: string): StatusReport;
+export declare function printStatus(report: StatusReport): void;
+export declare function statusCommand(): Promise<void>;
+export default statusCommand;

package/dist/cli/commands/storyteller.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Storyteller CLI Command
+ *
+ * Invokes the storyteller skill to write reflections, sagas, journeys, or narratives.
+ * Automatically determines story type based on context if not specified.
+ *
+ * Usage:
+ *   npx strray-ai storyteller reflection
+ *   npx strray-ai storyteller saga "v1.18.0 Release Journey"
+ *   npx strray-ai storyteller journey --title "API Migration"
+ *   npx strray-ai storyteller narrative --framework hero_journey
+ */
+export declare function storytellerCommand(storyType?: string, options?: {
+    title?: string;
+    framework?: string;
+    output?: string;
+    dryRun?: boolean;
+}): Promise<void>;
+export default storytellerCommand;

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * 0xRay CLI - Command Line Interface
+ *
+ * Provides commands for installing and managing 0xRay framework
+ */
+export {};

package/dist/cli/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/default-agents.d.ts

@@ -0,0 +1,12 @@
+export interface DefaultAgentConfig {
+    name: string;
+    capabilities: string[];
+    status: "active" | "inactive";
+    expertise: string;
+    capacity: number;
+    performance: number;
+    specialties: string[];
+}
+export declare const DEFAULT_AGENTS: DefaultAgentConfig[];
+export declare function getDefaultAgents(): DefaultAgentConfig[];
+export declare function getDefaultAgentByName(name: string): DefaultAgentConfig | undefined;

package/dist/core/activity-logger.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Activity Logger
+ *
+ * Comprehensive logging for all 0xRay activities including:
+ * - Framework operations
+ * - Development sessions
+ * - Script executions
+ * - File operations
+ * - Test results
+ *
+ * Enable/Disable via:
+ *   STRRAY_ACTIVITY_LOGGING=true  (enable)
+ *   STRRAY_ACTIVITY_LOGGING=false (disable, default)
+ *
+ * @module core/activity-logger
+ * @version 1.0.0
+ */
+export type ActivityCategory = "framework" | "development" | "script" | "file" | "test" | "commit" | "session" | "agent" | "processor" | "config";
+export type ActivityLevel = "debug" | "info" | "warn" | "error" | "success";
+export interface ActivityRecord {
+    timestamp: string;
+    id: string;
+    category: ActivityCategory;
+    level: ActivityLevel;
+    action: string;
+    message: string;
+    details?: Record<string, unknown>;
+    sessionId?: string;
+    jobId?: string;
+}
+/**
+ * Initialize activity logger with config from features.json
+ * Called by boot-orchestrator during initialization
+ */
+export declare function initializeActivityLogger(config?: {
+    enabled?: boolean;
+    log_path?: string;
+}): void;
+/**
+ * Check if activity logging is enabled
+ */
+export declare function isActivityLoggingEnabled(): boolean;
+/**
+ * Enable or disable activity logging
+ */
+export declare function setActivityLoggingEnabled(enabled: boolean): void;
+/**
+ * Get current session ID
+ */
+export declare function getSessionId(): string;
+/**
+ * Log an activity
+ */
+export declare function logActivity(category: ActivityCategory, level: ActivityLevel, action: string, message: string, details?: Record<string, unknown>, options?: {
+    sessionId?: string;
+    jobId?: string;
+}): void;
+export declare const activity: {
+    framework: (action: string, message: string, details?: Record<string, unknown>) => void;
+    development: (action: string, message: string, details?: Record<string, unknown>) => void;
+    script: (action: string, message: string, details?: Record<string, unknown>) => void;
+    file: (action: string, message: string, details?: Record<string, unknown>) => void;
+    test: (action: string, message: string, details?: Record<string, unknown>) => void;
+    commit: (action: string, message: string, details?: Record<string, unknown>) => void;
+    session: (action: string, message: string, details?: Record<string, unknown>) => void;
+    agent: (action: string, message: string, details?: Record<string, unknown>) => void;
+    processor: (action: string, message: string, details?: Record<string, unknown>) => void;
+    config: (action: string, message: string, details?: Record<string, unknown>) => void;
+    success: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+    error: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+    warn: (category: ActivityCategory, action: string, message: string, details?: Record<string, unknown>) => void;
+};

package/dist/core/adaptive-kernel.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Adaptive Kernel Extension for P9 - ADAPTIVE_PATTERN_LEARNING
+ *
+ * Composes with existing Kernel to add self-modifying pattern learning capabilities.
+ * Enables continuous pattern improvement based on performance data.
+ *
+ * @version 1.0.0
+ * @since 2026-03-05
+ */
+import { type KernelInferenceResult, type AdaptiveThresholds, type EmergentPattern, type PatternUpdate } from "../core/kernel-patterns.js";
+import { patternPerformanceTracker } from "../analytics/pattern-performance-tracker.js";
+import { emergingPatternDetector } from "../analytics/emerging-pattern-detector.js";
+import { patternLearningEngine } from "../analytics/pattern-learning-engine.js";
+export interface AdaptiveKernelConfig {
+    enabled: boolean;
+    enableP9Learning: boolean;
+    learningIntervalMs: number;
+    autoApplyThreshold: number;
+    confidenceThreshold: number;
+    maxPatternsPerAnalysis: number;
+}
+export interface P9AnalysisResult extends KernelInferenceResult {
+    patternDriftDetected: boolean;
+    driftAnalyses: Array<{
+        patternId: string;
+        driftMagnitude: number;
+        driftDirection: 'increasing' | 'decreasing' | 'unstable';
+        recommendedAction: string;
+    }>;
+    emergentPatterns: EmergentPattern[];
+    suggestedUpdates: PatternUpdate[];
+    adaptiveThresholds?: AdaptiveThresholds;
+    learningApplied: boolean;
+}
+export declare class AdaptiveKernelAnalyzer {
+    private adaptiveConfig;
+    private baseKernel;
+    private lastLearningRun;
+    private cachedP9Analysis;
+    private cacheValidMs;
+    constructor(config?: Partial<AdaptiveKernelConfig>);
+    /**
+     * Analyze observation using base kernel enhanced with P9 learning
+     */
+    analyze(observation: string): KernelInferenceResult;
+    /**
+     * Enhanced analyze with P9 learning capabilities
+     */
+    analyzeWithP9(observation: string): P9AnalysisResult;
+    /**
+     * Perform P9 adaptive pattern learning analysis
+     */
+    private performP9Analysis;
+    /**
+     * Get current adaptive thresholds
+     */
+    getAdaptiveThresholds(): AdaptiveThresholds;
+    /**
+     * Get pattern drift analyses
+     */
+    getPatternDrift(): Array<{
+        patternId: string;
+        driftMagnitude: number;
+        driftDirection: 'increasing' | 'decreasing' | 'unstable';
+        recommendedAction: string;
+    }>;
+    /**
+     * Manually trigger learning cycle
+     */
+    triggerLearning(outcomes: Array<{
+        taskId: string;
+        taskDescription: string;
+        routedAgent: string;
+        routedSkill: string;
+        confidence: number;
+        success: boolean;
+    }>, existingMappings: Array<{
+        keywords: string[];
+        skill: string;
+        agent: string;
+        confidence: number;
+    }>): {
+        newPatterns: number;
+        modifiedPatterns: number;
+        removedPatterns: number;
+        thresholdUpdates: number;
+        recommendations: string[];
+    };
+    /**
+     * Get learning statistics
+     */
+    getLearningStats(): {
+        lastLearningRun: Date;
+        cacheValid: boolean;
+        patternsTracked: number;
+        driftDetected: number;
+        thresholdsCalibrated: boolean;
+    };
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig: Partial<AdaptiveKernelConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): AdaptiveKernelConfig;
+}
+export declare function getAdaptiveKernel(config?: Partial<AdaptiveKernelConfig>): AdaptiveKernelAnalyzer;
+export { patternPerformanceTracker, emergingPatternDetector, patternLearningEngine };

package/dist/core/agent-spawn-gate.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Agent Spawn Gate — Singleton (provider-agnostic)
+ *
+ * CENTRALIZED CONTROL for all agent process spawning across StringRay
+ * (OpenCode, Hermes, or any other MCP-compatible host).
+ *
+ * Purpose:
+ *   Prevent runaway recursive agent spawning.
+ *
+ * Design:
+ *   - Singleton instance shared across all modules
+ *   - Explicit enable/disable with state persistence
+ *   - Tracks all active spawned processes for cleanup
+ *   - Gates every spawn path: inference, orchestrator, scripts, tests
+ *
+ * Usage:
+ *   import { spawnGate } from "./agent-spawn-gate.js";
+ *
+ *   // Before spawning
+ *   spawnGate.assertAllowed("inference-cycle");
+ *
+ *   // Global disable (emergency brake)
+ *   spawnGate.disable("emergency: runaway processes detected");
+ */
+declare class AgentSpawnGate {
+    private static instance;
+    private state;
+    private constructor();
+    static getInstance(): AgentSpawnGate;
+    /** Check if spawning is globally allowed */
+    isAllowed(): boolean;
+    /** Enable spawning (opt-in, not default) */
+    enable(reason: string): void;
+    /** Disable spawning globally */
+    disable(reason: string): void;
+    /** Assert spawning is allowed or throw */
+    assertAllowed(module: string): void;
+    /** Register a spawned process PID for tracking */
+    trackProcess(pid: number, module: string, description: string): void;
+    /** Unregister a process when it exits */
+    untrackProcess(pid: number): void;
+    /** Kill all tracked processes (emergency cleanup) */
+    killAllProcesses(signal?: NodeJS.Signals): Promise<number>;
+    /** Get current gate status */
+    getStatus(): {
+        enabled: boolean;
+        reason: string | undefined;
+        disabledAt: number | undefined;
+        activeProcesses: number;
+        totalSpawned: number;
+        totalBlocked: number;
+    };
+}
+/** Singleton export — use this everywhere (provider-agnostic) */
+export declare const spawnGate: AgentSpawnGate;
+export default spawnGate;

package/dist/core/boot-orchestrator.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Boot Orchestrator
+ *
+ * Implements orchestrator-first boot sequence with automatic enforcement activation.
+ * Coordinates the initialization of all framework components in the correct order.
+ *
+ * EXECUTION PATHS:
+ * - PRIMARY: .opencode/plugin/strray-codex-injection.js - Intercepts prompts in OpenCode
+ * - FALLBACK: This boot-orchestrator runs when plugin is not loaded
+ *
+ * The framework is designed to work through OpenCode's plugin system where:
+ *   1. StringRay plugin intercepts prompts via hooks
+ *   2. Routes to agents via .opencode/agents/*.yml configs
+ *   3. OpenCode spawns actual agent processes
+ *   4. Hermes Agent handles MCP server execution
+ *
+ * This orchestrator provides fallback initialization when the plugin isn't available.
+ *
+ * @version 1.1.2
+ * @since 2026-01-07
+ */
+import { StringRayStateManager } from "../state/state-manager.js";
+import { type MemoryStats } from "../monitoring/memory-monitor.js";
+export interface BootSequenceConfig {
+    enableEnforcement: boolean;
+    codexValidation: boolean;
+    sessionManagement: boolean;
+    processorActivation: boolean;
+    agentLoading: boolean;
+}
+export interface BootResult {
+    success: boolean;
+    orchestratorLoaded: boolean;
+    sessionManagementActive: boolean;
+    processorsActivated: boolean;
+    enforcementEnabled: boolean;
+    codexComplianceActive: boolean;
+    agentsLoaded: string[];
+    errors: string[];
+}
+export declare class BootOrchestrator {
+    private contextLoader;
+    private stateManager;
+    private processorManager;
+    private config;
+    private pluginRegistry?;
+    private pluginServerRegistry?;
+    private shutdownInitialized;
+    constructor(config?: Partial<BootSequenceConfig>, stateManager?: StringRayStateManager);
+    /**
+     * Initialize delegation system components
+     */
+    private initializeDelegationSystem;
+    private loadProcessorsConfig;
+    /**
+     * Initialize plugin system and register MCP servers
+     */
+    private initializePluginSystem;
+    /**
+     * Load orchestrator as the first component
+     */
+    private loadOrchestrator;
+    /**
+     * Initialize session management system
+     */
+    private initializeSessionManagement;
+    /**
+     * Activate pre/post processors
+     */
+    private activateProcessors;
+    /**
+     * Load remaining agents after orchestrator
+     */
+    private loadRemainingAgents;
+    /**
+     * Enable automatic enforcement activation
+     */
+    private enableEnforcement;
+    /**
+     * Activate codex compliance checking during boot
+     */
+    private activateCodexCompliance;
+    private initializeSecurityComponents;
+    private finalizeSecurityIntegration;
+    private runInitialSecurityAudit;
+    /**
+     * Validate processor health during boot
+     */
+    private validateProcessorHealth;
+    /**
+     * Get current boot status information
+     */
+    getBootStatus(): BootResult;
+    /**
+     * Set up comprehensive memory monitoring and alerting
+     */
+    private setupMemoryMonitoring;
+    /**
+     * Perform comprehensive memory health check
+     */
+    getMemoryHealth(): {
+        healthy: boolean;
+        issues: string[];
+        metrics: {
+            current: MemoryStats;
+            peak: MemoryStats;
+            average: number;
+            trend: string;
+        };
+    };
+    /**
+     * Execute the boot sequence (internal framework initialization)
+     */
+    executeBootSequence(): Promise<BootResult>;
+    /**
+     * Load 0xRay configuration from Python ConfigManager
+     */
+    private loadStringRayConfiguration;
+}
+export declare const bootOrchestrator: BootOrchestrator;

package/dist/core/boot-orchestrator.js

@@ -752,7 +752,7 @@ export class BootOrchestrator {
         try {
             // Load 0xRay configuration directly (no Python dependency)
             const stringRayConfig = {
-                version: "1.22.60",
+                version: "1.22.61",
                 codex_enabled: true,
                 codex_version: "v1.7.5",
                 codex_terms: [

package/dist/core/codex-formatter.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Codex Formatter — Standalone Codex-to-Prompt Converter
+ *
+ * Converts 0xRay's Universal Development Codex terms into
+ * formatted system prompt text. No OpenCode dependency, no plugin
+ * API, no framework imports. Pure input/output.
+ *
+ * This is the decoupled replacement for the codex injection that
+ * previously lived inside the OpenCode plugin (strray-codex-injection.ts).
+ *
+ * Usage from any host (Node.js, Python via bridge, HTTP, etc.):
+ *   import { formatCodexPrompt } from './codex-formatter.js';
+ *   const prompt = formatCodexPrompt({ projectRoot: '/path' });
+ *   // Append to system prompt
+ *
+ * @version 1.0.0
+ * @since 2026-03-28
+ */
+export interface CodexTerm {
+    id: string;
+    title: string;
+    description: string;
+    severity: "blocking" | "high" | "medium";
+    examples?: string[];
+}
+export interface CodexConfig {
+    version: string;
+    terms: CodexTerm[];
+    categories?: Record<string, string[]>;
+}
+export interface FormatOptions {
+    /** Project root for config resolution (default: cwd) */
+    projectRoot?: string;
+    /** Include only terms matching these severity levels (default: all) */
+    severityFilter?: Array<"blocking" | "high" | "medium">;
+    /** Include examples for each term (default: false) */
+    includeExamples?: boolean;
+    /** Maximum number of terms to include (default: all) */
+    maxTerms?: number;
+    /** Custom header text (default: auto-generated) */
+    header?: string;
+    /** Include config path reference in footer (default: true) */
+    includeConfigPath?: boolean;
+    /** Compress output by omitting descriptions for medium-severity terms */
+    compressed?: boolean;
+}
+export interface FormatResult {
+    /** The formatted prompt text */
+    prompt: string;
+    /** Number of terms included */
+    termCount: number;
+    /** Total terms available */
+    totalTerms: number;
+    /** Codex version */
+    version: string;
+    /** Config source path (or null if using built-in fallback) */
+    configPath: string | null;
+    /** Approximate character count */
+    charCount: number;
+}
+export declare const BUILTIN_CODEX: CodexConfig;
+/**
+ * Find codex.json using the standard priority chain.
+ * Mirrors config-paths.ts resolveCodexPath() but returns first match.
+ */
+export declare function findCodexPath(projectRoot?: string): string | null;
+/**
+ * Load and parse codex.json. Falls back to built-in codex if not found.
+ */
+export declare function loadCodex(projectRoot?: string): {
+    config: CodexConfig;
+    source: string | null;
+};
+/**
+ * Format codex terms into a system-prompt-ready string.
+ *
+ * This is the primary export. Any host (OpenCode, Hermes, Claude Desktop,
+ * custom agent) can call this to get enforcement text for their system prompt.
+ */
+export declare function formatCodexPrompt(options?: FormatOptions): FormatResult;
+/**
+ * Get codex as a structured JSON object (for programmatic consumers).
+ */
+export declare function getCodexConfig(options?: {
+    projectRoot?: string;
+}): {
+    version: string;
+    terms: CodexTerm[];
+    termCount: number;
+    source: string | null;
+};
+/**
+ * Get a minimal codex prompt for token-constrained environments.
+ * Only includes blocking terms, no descriptions.
+ */
+export declare function formatMinimalCodexPrompt(options?: FormatOptions): FormatResult;