create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/workflow-funnel-loader.js

@@ -1,135 +0,0 @@
-/**
- * WorkflowFunnelLoader — Loads and watches workflows.yaml as the SSOT
- * for WORKFLOW_FUNNELS definition table.
- *
- * D-01: workflows.yaml is the single source of truth (SSOT).
- * D-02: workflows.yaml lives in .state/ directory per workspace.
- * D-03: Developers manually maintain workflows.yaml (no auto-registration).
- * D-04: Code only reads YAML, never writes it.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-// ─────────────────────────────────────────────────────────────────────────────
-// WorkflowFunnelLoader
-// ─────────────────────────────────────────────────────────────────────────────
-export class WorkflowFunnelLoader {
-    funnels = new Map();
-    fullFunnels = new Map();
-    configPath;
-    watchHandle;
-    warnings = [];
-    constructor(stateDir) {
-        this.configPath = path.join(stateDir, 'workflows.yaml');
-        this.load();
-    }
-    load() {
-        this.warnings.length = 0;
-        if (!fs.existsSync(this.configPath)) {
-            this.warnings.push('workflows.yaml file not found.');
-            this.funnels.clear();
-            this.fullFunnels.clear();
-            return;
-        }
-        try {
-            const content = fs.readFileSync(this.configPath, 'utf-8');
-            const config = yaml.load(content, { schema: yaml.CORE_SCHEMA });
-            if (!config || typeof config.version !== 'string' || !Array.isArray(config.funnels)) {
-                const msg = 'workflows.yaml validation failed: missing version or funnels array. Preserving last valid config.';
-                console.warn(`[WorkflowFunnelLoader] ${msg}`);
-                this.warnings.push(msg);
-                return;
-            }
-            const newFunnels = new Map();
-            const newFullFunnels = new Map();
-            for (const funnel of config.funnels) {
-                if (funnel?.workflowId && typeof funnel.workflowId === 'string' && Array.isArray(funnel.stages)) {
-                    newFunnels.set(funnel.workflowId, funnel.stages);
-                    newFullFunnels.set(funnel.workflowId, funnel);
-                }
-                else {
-                    const msg = 'Skipping invalid funnel entry: missing workflowId or stages.';
-                    console.warn(`[WorkflowFunnelLoader] ${msg}`);
-                    this.warnings.push(msg);
-                }
-            }
-            this.funnels.clear();
-            this.fullFunnels.clear();
-            for (const [k, v] of newFunnels) {
-                this.funnels.set(k, v);
-            }
-            for (const [k, v] of newFullFunnels) {
-                this.fullFunnels.set(k, v);
-            }
-        }
-        catch (err) {
-            const msg = `Failed to parse workflows.yaml: ${String(err)}. Preserving last valid config.`;
-            console.warn(`[WorkflowFunnelLoader] ${msg}`);
-            this.warnings.push(msg);
-        }
-    }
-    watch() {
-        if (this.watchHandle)
-            return;
-        if (!fs.existsSync(this.configPath))
-            return;
-        let debounceTimer;
-        this.watchHandle = fs.watch(this.configPath, (eventType) => {
-            if (eventType !== 'change' && eventType !== 'rename')
-                return;
-            if (debounceTimer)
-                clearTimeout(debounceTimer);
-            debounceTimer = setTimeout(() => this.load(), 100);
-        });
-    }
-    dispose() {
-        if (this.watchHandle) {
-            this.watchHandle.close();
-            this.watchHandle = undefined;
-        }
-    }
-    getStages(workflowId) {
-        return this.funnels.get(workflowId) ?? [];
-    }
-    getFunnel(workflowId) {
-        const funnel = this.fullFunnels.get(workflowId);
-        if (!funnel)
-            return undefined;
-        return this.cloneFunnel(funnel);
-    }
-    getAllFunnels() {
-        const result = new Map();
-        for (const [k, v] of this.funnels) {
-            result.set(k, v.map(stage => ({ ...stage })));
-        }
-        return result;
-    }
-    getAllFunnelsWithPolicy() {
-        const result = new Map();
-        for (const [k, v] of this.fullFunnels) {
-            result.set(k, this.cloneFunnel(v));
-        }
-        return result;
-    }
-    getWarnings() {
-        return [...this.warnings];
-    }
-    getConfigPath() {
-        return this.configPath;
-    }
-    cloneFunnel(funnel) {
-        return {
-            ...funnel,
-            stages: funnel.stages.map(stage => ({ ...stage })),
-            policy: funnel.policy ? {
-                ...funnel.policy,
-                observability: funnel.policy.observability ? {
-                    ...funnel.policy.observability,
-                    emitEvents: funnel.policy.observability.emitEvents
-                        ? [...funnel.policy.observability.emitEvents]
-                        : undefined,
-                } : undefined,
-            } : undefined,
-        };
-    }
-}

package/plugin/dist/core/workspace-context.js

@@ -1,260 +0,0 @@
-import { resolvePdPath } from './paths.js';
-import { PathResolver } from './path-resolver.js';
-import { validateWorkspaceDir } from './workspace-dir-validation.js';
-import { ConfigService } from './config-service.js';
-import { EventLogService } from './event-log.js';
-import { DictionaryService } from './dictionary-service.js';
-import { HygieneTracker } from './hygiene/tracker.js';
-import { EvolutionReducerImpl } from './evolution-reducer.js';
-import { TrajectoryRegistry } from './trajectory.js';
-import { PrincipleLifecycleService } from './principle-internalization/principle-lifecycle-service.js';
-import { getPrincipleSubtree, updatePrinciple, updatePrincipleValueMetrics, } from './principle-tree-ledger.js';
-import { RuleHost } from './rule-host.js';
-/**
- * WorkspaceContext - Centralized management of workspace-specific paths and services.
- * Implements a cached singleton pattern per workspace directory.
- */
-export class WorkspaceContext {
-    static instances = new Map();
-    static pathResolver = new PathResolver();
-    workspaceDir;
-    stateDir;
-    _config;
-    _eventLog;
-    _dictionary;
-    _hygiene;
-    _evolutionReducer;
-    _trajectory;
-    _principleTreeLedger;
-    _principleLifecycle;
-    _ruleHost;
-    constructor(workspaceDir, stateDir) {
-        this.workspaceDir = workspaceDir;
-        this.stateDir = stateDir;
-    }
-    /**
-     * Governance configuration for this workspace.
-     */
-    get config() {
-        if (!this._config) {
-            this._config = ConfigService.get(this.stateDir);
-        }
-        return this._config;
-    }
-    /**
-     * Event logging service for this workspace.
-     */
-    get eventLog() {
-        if (!this._eventLog) {
-            this._eventLog = EventLogService.get(this.stateDir);
-        }
-        return this._eventLog;
-    }
-    /**
-     * Pain dictionary service for this workspace.
-     */
-    get dictionary() {
-        if (!this._dictionary) {
-            this._dictionary = DictionaryService.get(this.stateDir);
-        }
-        return this._dictionary;
-    }
-    /**
-     * Hygiene tracking service for this workspace.
-     */
-    get hygiene() {
-        if (!this._hygiene) {
-            this._hygiene = new HygieneTracker(this.stateDir);
-        }
-        return this._hygiene;
-    }
-    /**
-     * Evolution reducer singleton for this workspace.
-     */
-    get evolutionReducer() {
-        if (!this._evolutionReducer) {
-            this._evolutionReducer = new EvolutionReducerImpl({ workspaceDir: this.workspaceDir, stateDir: this.stateDir });
-        }
-        return this._evolutionReducer;
-    }
-    /**
-     * Trajectory database for analytics and sample curation.
-     */
-    get trajectory() {
-        if (!this._trajectory) {
-            this._trajectory = TrajectoryRegistry.get(this.workspaceDir, this.getTrajectoryOptions());
-        }
-        return this._trajectory;
-    }
-    getRuleHost(logger) {
-        if (!this._ruleHost) {
-            this._ruleHost = new RuleHost(this.stateDir, logger, { workspaceDir: this.workspaceDir });
-        }
-        else {
-            this._ruleHost.updateLogger(logger);
-        }
-        return this._ruleHost;
-    }
-    /**
-     * Locked ledger access for principle tree reads and metric writes in this workspace.
-     */
-    get principleTreeLedger() {
-        if (!this._principleTreeLedger) {
-            this._principleTreeLedger = {
-                getPrincipleSubtree: (principleId) => getPrincipleSubtree(this.stateDir, principleId),
-                updatePrinciple: (principleId, updates) => updatePrinciple(this.stateDir, principleId, updates),
-                updatePrincipleValueMetrics: (principleId, metrics) => updatePrincipleValueMetrics(this.stateDir, principleId, metrics),
-            };
-        }
-        return this._principleTreeLedger;
-    }
-    /**
-     * Phase 15 lifecycle/read-model surface for metrics, assessments, and route recommendations.
-     */
-    get principleLifecycle() {
-        if (!this._principleLifecycle) {
-            this._principleLifecycle = new PrincipleLifecycleService(this.workspaceDir, this.stateDir);
-        }
-        return this._principleLifecycle;
-    }
-    /**
-     * Retrieve active Principle -> Rule -> Implementation subtrees without bypassing reducer authority.
-     */
-    getActivePrincipleSubtrees() {
-        return this.evolutionReducer
-            .getActivePrinciples()
-            .map((principle) => {
-            const subtree = this.principleTreeLedger.getPrincipleSubtree(principle.id);
-            return subtree ? { principle, subtree } : null;
-        })
-            .filter((entry) => entry !== null);
-    }
-    getTrajectoryOptions() {
-        const inlineThreshold = Number(this.config.get('trajectory.blob_inline_threshold_bytes'));
-        const busyTimeoutMs = Number(this.config.get('trajectory.busy_timeout_ms'));
-        const orphanBlobGraceDays = Number(this.config.get('trajectory.orphan_blob_grace_days'));
-        return {
-            blobInlineThresholdBytes: Number.isFinite(inlineThreshold) && inlineThreshold > 0 ? inlineThreshold : undefined,
-            busyTimeoutMs: Number.isFinite(busyTimeoutMs) && busyTimeoutMs >= 0 ? busyTimeoutMs : undefined,
-            orphanBlobGraceDays: Number.isFinite(orphanBlobGraceDays) && orphanBlobGraceDays >= 0 ? orphanBlobGraceDays : undefined,
-        };
-    }
-    /**
-     * Creates or retrieves a WorkspaceContext instance from an OpenClaw hook context.
-     * Uses PathResolver to handle path normalization and fallback logic.
-     * @throws Error if workspaceDir is missing and no fallback available.
-     */
-    static fromHookContext(ctx) {
-        const { logger } = ctx;
-        const log = (msg) => logger?.info?.(msg);
-        const logWarn = (msg) => logger?.warn?.(msg);
-        let { workspaceDir } = ctx;
-        if (!workspaceDir) {
-            logWarn('[PD:WorkspaceContext] workspaceDir not provided in context, using PathResolver fallback');
-            workspaceDir = this.pathResolver.getWorkspaceDir();
-            log(`[PD:WorkspaceContext] Resolved workspaceDir to: ${workspaceDir}`);
-        }
-        else {
-            const normalized = this.pathResolver.normalizeWorkspacePath(workspaceDir);
-            if (normalized !== workspaceDir) {
-                log(`[PD:WorkspaceContext] Normalized workspaceDir: ${workspaceDir} -> ${normalized}`);
-                workspaceDir = normalized;
-            }
-        }
-        const validationIssue = validateWorkspaceDir(workspaceDir);
-        if (validationIssue !== null) {
-            logWarn(`[PD:WorkspaceContext] LEGACY_PATH_RESOLVER_FALLBACK: ${validationIssue}. ` +
-                'This is a legacy discovery path; explicit workspaceDir should be provided in the hook context.');
-        }
-        const existing = this.instances.get(workspaceDir);
-        if (existing)
-            return existing;
-        let { stateDir } = ctx;
-        if (!stateDir) {
-            stateDir = resolvePdPath(workspaceDir, 'STATE_DIR');
-            log(`[PD:WorkspaceContext] Computed stateDir: ${stateDir}`);
-        }
-        const instance = new WorkspaceContext(workspaceDir, stateDir);
-        this.instances.set(workspaceDir, instance);
-        log(`[PD:WorkspaceContext] Created new context for workspace: ${workspaceDir}`);
-        return instance;
-    }
-    /**
-     * Creates a WorkspaceContext requiring explicit workspaceDir.
-     * For Runtime V2 entrypoints where implicit PathResolver fallback is unacceptable.
-     * @throws Error if workspaceDir is not provided in the context.
-     */
-    static fromHookContextExplicit(ctx) {
-        const { logger } = ctx;
-        let { workspaceDir } = ctx;
-        if (!workspaceDir || !workspaceDir.trim()) {
-            const error = {
-                ok: false,
-                reason: 'workspace_dir_missing',
-                message: 'workspaceDir is required for Runtime V2 entrypoints. Provide it explicitly in the hook context.',
-                nextAction: 'Ensure the OpenClaw hook context includes workspaceDir, or use PD_WORKSPACE_DIR env var.',
-            };
-            logger?.error?.(`[PD:WorkspaceContext] ${error.message}`);
-            throw new Error(`[PD:WorkspaceContext] ${error.reason}: ${error.message}`);
-        }
-        const normalized = this.pathResolver.normalizeWorkspacePath(workspaceDir);
-        if (normalized !== workspaceDir) {
-            logger?.info?.(`[PD:WorkspaceContext] Normalized workspaceDir before validation: ${workspaceDir} -> ${normalized}`);
-            workspaceDir = normalized;
-        }
-        const validationIssue = validateWorkspaceDir(workspaceDir);
-        if (validationIssue !== null) {
-            const error = {
-                ok: false,
-                reason: 'workspace_dir_invalid',
-                message: `workspaceDir validation failed for Runtime V2 entrypoint: ${validationIssue}`,
-                nextAction: 'Provide a valid workspaceDir that is not the home directory, root, or empty.',
-            };
-            logger?.error?.(`[PD:WorkspaceContext] ${error.message}`);
-            throw new Error(`[PD:WorkspaceContext] ${error.reason}: ${error.message}`);
-        }
-        return this.fromHookContext({ ...ctx, workspaceDir });
-    }
-    /**
-     * Resolves a PD file path within the workspace.
-     */
-    resolve(fileKey) {
-        return resolvePdPath(this.workspaceDir, fileKey);
-    }
-    /**
-     * Resets internal caches for services and paths.
-     */
-    invalidate() {
-        this._ruleHost?.dispose();
-        this._ruleHost = undefined;
-        this._config = undefined;
-        this._eventLog = undefined;
-        this._dictionary = undefined;
-        this._evolutionReducer = undefined;
-        this._trajectory = undefined;
-        this._principleTreeLedger = undefined;
-        this._principleLifecycle = undefined;
-    }
-    /**
-     * Removes a workspace from the cache.
-     */
-    static dispose(workspaceDir) {
-        const normalized = this.pathResolver.normalizeWorkspacePath(workspaceDir);
-        const instance = this.instances.get(normalized);
-        if (instance) {
-            instance.invalidate();
-            this.instances.delete(normalized);
-        }
-        TrajectoryRegistry.dispose(normalized);
-    }
-    /**
-     * Clears the instance cache (primarily for testing).
-     */
-    static clearCache() {
-        for (const instance of this.instances.values()) {
-            instance.invalidate();
-        }
-        this.instances.clear();
-        TrajectoryRegistry.clear();
-    }
-}

package/plugin/dist/core/workspace-dir-validation.js

@@ -1,37 +0,0 @@
-/**
- * WorkspaceDir Validation Utilities
- *
- * This module only validates candidate workspace directories. Runtime hook
- * resolution policy lives at the I/O boundary in utils/workspace-resolver.ts.
- */
-import * as os from 'os';
-import * as path from 'path';
-export function validateWorkspaceDir(dir) {
-    if (!dir) {
-        return 'workspaceDir is undefined/null';
-    }
-    if (/^[A-Za-z]:\\?$/.test(dir)) {
-        return `workspaceDir is a drive root: "${dir}"`;
-    }
-    const resolved = path.resolve(dir);
-    const homeDir = os.homedir();
-    if (resolved === homeDir) {
-        return `workspaceDir equals home directory (${homeDir}), likely missing context field`;
-    }
-    if (resolved === '/' || resolved === '') {
-        return `workspaceDir is root or empty: "${resolved}"`;
-    }
-    if (/^[A-Za-z]:\\?$/.test(resolved)) {
-        return `workspaceDir is a drive root: "${resolved}"`;
-    }
-    const escapedHome = homeDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const badPatterns = [
-        { pattern: new RegExp(`^${escapedHome}[\\\\/]?$`), desc: 'is home directory' },
-    ];
-    for (const { pattern, desc } of badPatterns) {
-        if (pattern.test(resolved)) {
-            return `workspaceDir ${desc}: "${resolved}"`;
-        }
-    }
-    return null;
-}

package/plugin/dist/core/workspace-guidance-migrator.js

@@ -1,141 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { migrateWorkspaceGuidance, containsStalePlanMdGuidance } from '@principles/core/runtime-v2';
-const WORKSPACE_GUIDANCE_FILES = [
-    'AGENTS.md',
-    'MEMORY.md',
-];
-const PRINCIPLES_SUBDIR_FILES = [
-    'THINKING_OS.md',
-];
-const SKILLS_DIR = path.join('.principles', 'skills');
-const PRINCIPLES_DIR = '.principles';
-const BACKUP_SUFFIX = '.pre-pri286.bak';
-function readFileContent(filePath) {
-    try {
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        if (typeof raw !== 'string') {
-            return null;
-        }
-        return raw;
-    }
-    catch {
-        return null;
-    }
-}
-function writeBackup(filePath, content) {
-    const backupPath = filePath + BACKUP_SUFFIX;
-    try {
-        fs.writeFileSync(backupPath, content, 'utf-8');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function discoverSkillFiles(workspaceDir) {
-    const skillsDir = path.join(workspaceDir, SKILLS_DIR);
-    if (!fs.existsSync(skillsDir)) {
-        return { files: [] };
-    }
-    try {
-        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
-        const skillFiles = [];
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const skillMd = path.join(skillsDir, entry.name, 'SKILL.md');
-                if (fs.existsSync(skillMd)) {
-                    skillFiles.push(skillMd);
-                }
-            }
-        }
-        return { files: skillFiles };
-    }
-    catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        return {
-            files: [],
-            error: {
-                file: SKILLS_DIR,
-                error: `Failed to enumerate skills directory: ${errMsg}`,
-            },
-        };
-    }
-}
-function collectCandidateFiles(workspaceDir, result) {
-    const candidates = [];
-    for (const filename of WORKSPACE_GUIDANCE_FILES) {
-        candidates.push(path.join(workspaceDir, filename));
-    }
-    for (const filename of PRINCIPLES_SUBDIR_FILES) {
-        candidates.push(path.join(workspaceDir, PRINCIPLES_DIR, filename));
-    }
-    const skillDiscovery = discoverSkillFiles(workspaceDir);
-    if (skillDiscovery.error) {
-        result.errors.push(skillDiscovery.error);
-    }
-    candidates.push(...skillDiscovery.files);
-    return candidates;
-}
-export function migrateStaleWorkspaceGuidance(api, workspaceDir) {
-    const result = {
-        migratedFiles: [],
-        skippedFiles: [],
-        errors: [],
-    };
-    const candidates = collectCandidateFiles(workspaceDir, result);
-    for (const filePath of candidates) {
-        const relativePath = path.relative(workspaceDir, filePath);
-        if (!fs.existsSync(filePath)) {
-            continue;
-        }
-        const content = readFileContent(filePath);
-        if (content === null) {
-            result.errors.push({
-                file: relativePath,
-                error: 'Failed to read file content',
-            });
-            continue;
-        }
-        if (!containsStalePlanMdGuidance(content, relativePath)) {
-            result.skippedFiles.push(relativePath);
-            continue;
-        }
-        const migrationResult = migrateWorkspaceGuidance(content, relativePath);
-        if (!migrationResult.changed) {
-            result.skippedFiles.push(relativePath);
-            continue;
-        }
-        const migrated = migrationResult.migrated;
-        const backupOk = writeBackup(filePath, content);
-        if (!backupOk) {
-            result.errors.push({
-                file: relativePath,
-                error: 'Failed to create backup file before migration',
-            });
-            continue;
-        }
-        try {
-            fs.writeFileSync(filePath, migrated, 'utf-8');
-            result.migratedFiles.push(relativePath);
-            api.logger.info(`[PD:GuidanceMigration] Migrated ${relativePath} (backup at ${relativePath}${BACKUP_SUFFIX})`);
-        }
-        catch (writeErr) {
-            const errMsg = writeErr instanceof Error ? writeErr.message : String(writeErr);
-            result.errors.push({
-                file: relativePath,
-                error: `Failed to write migrated content: ${errMsg}`,
-            });
-            try {
-                fs.writeFileSync(filePath, content, 'utf-8');
-            }
-            catch {
-                api.logger.error(`[PD:GuidanceMigration] CRITICAL: Failed to restore original content for ${relativePath} after write failure`);
-            }
-        }
-    }
-    if (result.migratedFiles.length > 0) {
-        api.logger.info(`[PD:GuidanceMigration] Migration complete: ${result.migratedFiles.length} migrated, ${result.skippedFiles.length} skipped, ${result.errors.length} errors`);
-    }
-    return result;
-}