create-principles-disciple 1.103.0 → 1.104.1

package/plugin/dist/core/migration.js

@@ -1,86 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { resolvePdPath } from './paths.js';
-/**
- * Handles migration of Principles Disciple files from legacy directories
- * (docs/ and memory/.state/) to the new hidden directory structure (.principles/ and .state/).
- */
-export function migrateDirectoryStructure(api, workspaceDir) {
-    try {
-        const legacyDocsDir = path.join(workspaceDir, 'docs');
-        const legacyStateDir = path.join(workspaceDir, 'memory', '.state');
-        // Comprehensive migration map covering ALL legacy locations
-        const migrationMap = [
-            // From docs/
-            { legacy: path.join(legacyDocsDir, 'PRINCIPLES.md'), newKey: 'PRINCIPLES' },
-            { legacy: path.join(legacyDocsDir, 'THINKING_OS.md'), newKey: 'THINKING_OS' },
-            { legacy: path.join(legacyDocsDir, 'DECISION_POLICY.json'), newKey: 'DECISION_POLICY' },
-            { legacy: path.join(legacyDocsDir, 'evolution_queue.json'), newKey: 'EVOLUTION_QUEUE' },
-            { legacy: path.join(legacyDocsDir, '.pain_flag'), newKey: 'PAIN_FLAG' },
-            { legacy: path.join(legacyDocsDir, 'SYSTEM_CAPABILITIES.json'), newKey: 'SYSTEM_CAPABILITIES' },
-            { legacy: path.join(legacyDocsDir, 'SYSTEM.log'), newKey: 'SYSTEM_LOG' },
-            { legacy: path.join(legacyDocsDir, 'THINKING_OS_CANDIDATES.md'), newKey: 'THINKING_OS_CANDIDATES' },
-            // From memory/.state/ (The hidden legacy state)
-            { legacy: path.join(legacyStateDir, 'pain_dictionary.json'), newKey: 'DICTIONARY' },
-            { legacy: path.join(legacyStateDir, 'pain_settings.json'), newKey: 'PAIN_SETTINGS' },
-            { legacy: path.join(legacyStateDir, 'thinking_os_usage.json'), newKey: 'THINKING_OS_USAGE' },
-            { legacy: path.join(legacyStateDir, 'pain_candidates.json'), newKey: 'PAIN_CANDIDATES' },
-            { legacy: path.join(legacyStateDir, 'evolution_directive.json'), newKey: 'EVOLUTION_DIRECTIVE' },
-            { legacy: path.join(legacyStateDir, 'sessions'), newKey: 'SESSION_DIR' },
-            { legacy: path.join(legacyStateDir, 'logs', 'events.jsonl'), newKey: 'SYSTEM_LOG' }, // Backup plan for logs
-        ];
-        let migratedCount = 0;
-        for (const entry of migrationMap) {
-            if (fs.existsSync(entry.legacy)) {
-                const newPath = resolvePdPath(workspaceDir, entry.newKey);
-                const newDir = path.dirname(newPath);
-                if (!fs.existsSync(newDir)) {
-                    fs.mkdirSync(newDir, { recursive: true });
-                }
-                // If it's a file, rename it. If it's a directory (sessions), handle carefully.
-                if (!fs.existsSync(newPath)) {
-                    try {
-                        fs.renameSync(entry.legacy, newPath);
-                        api.logger.info(`[PD:Migration] Migrated ${path.basename(entry.legacy)} to ${newPath.replace(workspaceDir, '')}`);
-                        migratedCount++;
-                    }
-                    catch (renameErr) {
-                        api.logger.error(`[PD:Migration] Failed to rename ${entry.legacy}: ${String(renameErr)}`);
-                    }
-                }
-                else {
-                    // Special case: Log append instead of overwrite if it's SYSTEM_LOG? 
-                    // For now, keep it simple and skip if exists to avoid data corruption.
-                    api.logger?.warn?.(`[PD:Migration] Skipping ${path.basename(entry.legacy)}: already exists at destination.`);
-                }
-            }
-        }
-        if (migratedCount > 0) {
-            api.logger.info(`[PD:Migration] Successfully migrated ${migratedCount} files/folders to new architecture.`);
-        }
-        // Final cleanup: Try to remove legacy state dir if empty
-        if (fs.existsSync(legacyStateDir)) {
-            try {
-                // Check if dir is empty (recursive check not needed here as we moved main subdirs)
-                const items = fs.readdirSync(legacyStateDir);
-                if (items.length === 0 || (items.length === 1 && items[0] === 'logs')) {
-                    // Try to clean up logs dir if empty too
-                    const logsDir = path.join(legacyStateDir, 'logs');
-                    if (fs.existsSync(logsDir) && fs.readdirSync(logsDir).length === 0) {
-                        fs.rmdirSync(logsDir);
-                    }
-                    if (fs.readdirSync(legacyStateDir).length === 0) {
-                        fs.rmdirSync(legacyStateDir);
-                        api.logger.info(`[PD:Migration] Cleaned up empty legacy state directory.`);
-                    }
-                }
-            }
-            catch (_e) {
-                api.logger.debug?.(`[PD:Migration] Failed to cleanup legacy state dir: ${String(_e)}`);
-            }
-        }
-    }
-    catch (err) {
-        api.logger.error(`[PD:Migration] Directory refactor migration failed: ${String(err)}`);
-    }
-}

package/plugin/dist/core/pain-diagnostic-gate.js

@@ -1,69 +0,0 @@
-/**
- * Pain Diagnostic Gate — PRI-446 thin adapter
- *
- * @deprecated PRI-454 — Gate A (PainDiagnosticGate) is superseded by Gate B
- * (TriggerController + EvidenceTriage). This module remains as the rollback
- * path when `painEvidenceAdmission` or `painEvidenceAdmissionDefault` flags
- * are OFF. Do not add new callers. New admission logic must use
- * `evaluateTriggerController` from runtime-v2/evidence-triage.
- *
- * Disposition: Archive (do not delete) per PRI-454 plan step 6.
- * Removal conditions: Both flags confirmed ON in production for 30 days,
- * and all 5 MVP paths verified on Gate B. See
- * docs/plans/2026-06-pain-evidence-admission-track.md.
- *
- * The pure decision logic (threshold tree, cooldown comparison, episode-key
- * construction) now lives in principles-core
- * (runtime-v2/pain-gate/pain-diagnostic-gate-policy.ts). This file is the
- * stateful adapter that owns:
- *   - the cooldown Map (lastDiagnosedAtByEpisode)
- *   - Date.now() injection
- *   - SystemLogger for unknown-source telemetry
- *
- * It preserves the original export names (evaluatePainDiagnosticGate,
- * isCooldownActiveForEpisode, resetPainDiagnosticGateForTest) so all 5 callers
- * (gate-block-helper, llm, pain, prompt x2) and the characterization test keep
- * working unchanged.
- *
- * ERR checklist:
- * - ERR-011: this is a stateful adapter delegating to core pure logic.
- */
-import { SystemLogger } from './system-logger.js';
-import { evaluatePainDiagnosticGateDecision, normalizedSource, buildEpisodeKey, isCooldownActive as isCooldownActiveCore, } from '@principles/core/runtime-v2';
-// Module-level cooldown state — owned by this adapter (core is stateless).
-const lastDiagnosedAtByEpisode = new Map();
-export function resetPainDiagnosticGateForTest() {
-    lastDiagnosedAtByEpisode.clear();
-}
-/**
- * Check whether cooldown is currently active for a given episode.
- * Used by the trigger controller (PEAT-B2) to align its cooldown decision
- * with the PainDiagnosticGate's cooldown state.
- */
-export function isCooldownActiveForEpisode(source, sessionId, errorHash, cooldownMs) {
-    const episodeKey = buildEpisodeKey({ source, sessionId, errorHash, score: 0, currentGfi: 0 });
-    const last = lastDiagnosedAtByEpisode.get(episodeKey);
-    const nowMs = Date.now();
-    return isCooldownActiveCore({ source, sessionId, errorHash, cooldownMs, nowMs, lastDiagnosedAtMs: last });
-}
-/**
- * Evaluate the pain diagnostic gate. Delegates the pure decision to core and,
- * when the decision is to diagnose, records the current time against the
- * episode so subsequent calls within the cooldown window are suppressed.
- */
-export function evaluatePainDiagnosticGate(input) {
-    // Surface unknown sources via telemetry (core cannot log).
-    const { unknown } = normalizedSource(input.source);
-    if (unknown) {
-        SystemLogger.log('', 'GATE_UNKNOWN_SOURCE', `Unknown pain source: "${input.source}"`);
-    }
-    const episodeKey = buildEpisodeKey(input);
-    const last = lastDiagnosedAtByEpisode.get(episodeKey);
-    const nowMs = input.nowMs ?? Date.now();
-    const decision = evaluatePainDiagnosticGateDecision({ ...input, nowMs }, last);
-    // Record the diagnosis time when approved (matches prior markDiagnosed behavior).
-    if (decision.shouldDiagnose) {
-        lastDiagnosedAtByEpisode.set(episodeKey, nowMs);
-    }
-    return decision;
-}

package/plugin/dist/core/pain.js

@@ -1,56 +0,0 @@
-import { resolvePdPath } from './paths.js';
-import { ConfigService } from './config-service.js';
-export function computePainScore(rc, isSpiral, missingTestCommand, softScore, projectDir) {
-    let score = Math.max(0, softScore || 0);
-    const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
-    const config = stateDir ? ConfigService.get(stateDir) : null;
-    const scoreSettings = config ? config.get('scores') : {
-        exit_code_penalty: 70,
-        spiral_penalty: 40,
-        missing_test_command_penalty: 30
-    };
-    if (rc !== 0) {
-        score += scoreSettings.exit_code_penalty;
-    }
-    if (isSpiral) {
-        score += scoreSettings.spiral_penalty;
-    }
-    if (missingTestCommand) {
-        score += scoreSettings.missing_test_command_penalty;
-    }
-    return Math.min(100, score);
-}
-/**
- * Track principle value metrics when a pain signal is written.
- * This is observation-only — it does NOT affect the pain flag write flow.
- * If any principle matches the pain signal, its painPreventedCount is incremented.
- * Errors are silently ignored to avoid disrupting the pain pipeline.
- */
-export function trackPrincipleValue(workspaceDir, painData, getActivePrinciples, updatePrincipleMetrics) {
-    try {
-        const activePrinciples = getActivePrinciples();
-        if (!activePrinciples.length)
-            return;
-        const painText = `${painData.reason || ''} ${painData.source || ''}`.toLowerCase();
-        const now = new Date().toISOString();
-        for (const principle of activePrinciples) {
-            const triggerPattern = principle.trigger?.toLowerCase();
-            if (!triggerPattern)
-                continue;
-            // Simple keyword match — if any word from the trigger appears in the pain text
-            const triggerWords = triggerPattern.split(/[\s|\\.+*?()[\]{}^$-]+/).filter((w) => w.length > 2);
-            const matchCount = triggerWords.filter((word) => painText.includes(word)).length;
-            if (matchCount >= 2 || (triggerWords.length <= 3 && matchCount >= 1)) {
-                const currentMetrics = principle.valueMetrics ?? { painPreventedCount: 0, calculatedAt: now };
-                updatePrincipleMetrics(principle.id, {
-                    painPreventedCount: currentMetrics.painPreventedCount + 1,
-                    lastPainPreventedAt: now,
-                    calculatedAt: now,
-                });
-            }
-        }
-    }
-    catch {
-        // Observation only — never disrupt the pain pipeline
-    }
-}

package/plugin/dist/core/path-resolver.js

@@ -1,358 +0,0 @@
-import * as path from 'path';
-import * as os from 'os';
-import * as fs from 'fs';
-import { PathResolutionError } from '../config/index.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-const DEFAULT_WORKSPACE_SUBPATH = '.openclaw/workspace';
-export const PD_ENV_VARS = {
-    WORKSPACE_DIR: 'PD_WORKSPACE_DIR',
-    STATE_DIR: 'PD_STATE_DIR',
-    DEBUG: 'DEBUG',
-};
-export const PD_ENV_DESCRIPTIONS = {
-    WORKSPACE_DIR: {
-        desc: 'Override the default workspace directory',
-        example: 'PD_WORKSPACE_DIR=/home/user/my-workspace',
-    },
-    STATE_DIR: {
-        desc: 'Override the default state directory (.state)',
-        example: 'PD_STATE_DIR=/home/user/my-workspace/.state',
-    },
-    DEBUG: {
-        desc: 'Enable debug logging for path resolution',
-        example: 'DEBUG=true',
-    },
-};
-export function printEnvVarHelp() {
-    console.log('\n📁 Principles Disciple - Environment Variables\n');
-    console.log('You can customize directory paths using environment variables:\n');
-    for (const [key, varName] of Object.entries(PD_ENV_VARS)) {
-        const info = PD_ENV_DESCRIPTIONS[key];
-        console.log(`  ${varName}`);
-        console.log(`    Description: ${info.desc}`);
-        console.log(`    Example: ${info.example}`);
-        console.log();
-    }
-    console.log('💡 Tips:');
-    console.log('  - These can be set in your shell profile (~/.bashrc, ~/.zshrc)');
-    console.log('  - Or passed when starting OpenClaw gateway');
-    console.log('  - Example: PD_WORKSPACE_DIR=/custom/path openclaw-gateway start\n');
-}
-const PD_CONFIG_FILE = 'principles-disciple.json';
-const PD_CONFIG_LOCATIONS = [
-    path.join(process.cwd(), PD_CONFIG_FILE),
-    path.join(os.homedir(), '.openclaw', PD_CONFIG_FILE),
-    path.join(os.homedir(), '.principles', PD_CONFIG_FILE),
-];
-function isWindowsPath(inputPath) {
-    return /^[A-Za-z]:[\\/]/.test(inputPath) || inputPath.startsWith('\\\\');
-}
-function isPosixAbsolutePath(inputPath) {
-    return inputPath.startsWith('/');
-}
-function getPathApi(inputPath) {
-    if (isWindowsPath(inputPath)) {
-        return path.win32;
-    }
-    if (isPosixAbsolutePath(inputPath)) {
-        return path.posix;
-    }
-    return path;
-}
-function findConfigFile() {
-    for (const loc of PD_CONFIG_LOCATIONS) {
-        if (fs.existsSync(loc)) {
-            return loc;
-        }
-    }
-    return null;
-}
-function loadConfigFromFile() {
-    const configPath = findConfigFile();
-    if (!configPath) {
-        return null;
-    }
-    try {
-        const content = fs.readFileSync(configPath, 'utf8');
-        const config = JSON.parse(content);
-        console.log(`[PD:PathResolver] Loaded config from: ${configPath}`);
-        return config;
-    }
-    catch (e) {
-        console.warn(`[PD:PathResolver] Failed to load config from ${configPath}: ${String(e)}`);
-        return null;
-    }
-}
-export class PathResolver {
-    static extensionRoot = null;
-    workspaceDir = null;
-    stateDir = null;
-    logger;
-    normalizeWorkspace;
-    initialized = false;
-    static setExtensionRoot(extensionRootPath) {
-        if (!extensionRootPath || !extensionRootPath.trim()) {
-            return;
-        }
-        const trimmed = extensionRootPath.trim();
-        const pathApi = getPathApi(trimmed);
-        PathResolver.extensionRoot = pathApi.normalize(trimmed);
-    }
-    static getExtensionRoot() {
-        return PathResolver.extensionRoot;
-    }
-    constructor(options = {}) {
-        this.logger = options.logger;
-        this.normalizeWorkspace = options.normalizeWorkspace ?? true;
-        if (options.workspaceDir) {
-            const original = options.workspaceDir;
-            const normalized = this.normalizeWorkspace ? this.normalizePath(original) : original;
-            if (original !== normalized) {
-                this.log('info', `Workspace path normalized: ${original} -> ${normalized}`);
-            }
-            this.workspaceDir = normalized;
-            this.initialized = true;
-        }
-    }
-    log(level, msg) {
-        const prefix = '[PD:PathResolver]';
-        const fullMsg = `${prefix} ${msg}`;
-        if (process.env.DEBUG === 'true') {
-            this.logger?.debug?.(fullMsg);
-        }
-        switch (level) {
-            case 'debug':
-                this.logger?.debug?.(fullMsg);
-                break;
-            case 'info':
-                this.logger?.info?.(fullMsg);
-                break;
-            case 'warn':
-                this.logger?.warn?.(fullMsg);
-                break;
-            case 'error':
-                this.logger?.error?.(fullMsg);
-                break;
-        }
-    }
-    detectWorkspaceDir() {
-        const envWorkspace = process.env.PD_WORKSPACE_DIR;
-        if (envWorkspace && envWorkspace.trim()) {
-            this.log('info', `Using workspace from PD_WORKSPACE_DIR: ${envWorkspace}`);
-            return envWorkspace.trim();
-        }
-        const envOpenclaw = process.env.OPENCLAW_WORKSPACE;
-        if (envOpenclaw && envOpenclaw.trim()) {
-            this.log('info', `Using workspace from OPENCLAW_WORKSPACE: ${envOpenclaw}`);
-            return envOpenclaw.trim();
-        }
-        const fileConfig = loadConfigFromFile();
-        if (fileConfig?.workspace) {
-            this.log('info', `Using workspace from config file: ${fileConfig.workspace}`);
-            return fileConfig.workspace;
-        }
-        const homeDir = os.homedir();
-        const defaultWorkspace = path.join(homeDir, DEFAULT_WORKSPACE_SUBPATH);
-        this.log('info', `Using default workspace: ${defaultWorkspace}`);
-        return defaultWorkspace;
-    }
-    normalizePath(inputPath) {
-        const pathApi = getPathApi(inputPath);
-        let normalized = pathApi === path ? path.resolve(inputPath) : pathApi.normalize(inputPath);
-        if (this.normalizeWorkspace) {
-            const problematicSuffixes = ['/memory', '/docs', '\\memory', '\\docs'];
-            for (const suffix of problematicSuffixes) {
-                if (normalized.endsWith(suffix)) {
-                    const parent = pathApi.dirname(normalized);
-                    this.log('warn', `Detected subdirectory suffix '${suffix}' in path. Normalized to parent: ${parent}`);
-                    normalized = parent;
-                    break;
-                }
-            }
-        }
-        return normalized;
-    }
-    normalizeWorkspacePath(inputPath) {
-        return this.normalizePath(inputPath);
-    }
-    getWorkspaceDir() {
-        if (this.initialized && this.workspaceDir) {
-            return this.workspaceDir;
-        }
-        let dir = this.detectWorkspaceDir();
-        if (this.normalizeWorkspace) {
-            const originalDir = dir;
-            dir = this.normalizePath(dir);
-            if (originalDir !== dir) {
-                this.log('info', `Workspace path normalized: ${originalDir} -> ${dir}`);
-            }
-        }
-        this.workspaceDir = dir;
-        this.initialized = true;
-        this.log('debug', `Final workspace directory: ${this.workspaceDir}`);
-        return this.workspaceDir;
-    }
-    getStateDir() {
-        if (this.stateDir) {
-            return this.stateDir;
-        }
-        const envStateDir = process.env.PD_STATE_DIR;
-        if (envStateDir && envStateDir.trim()) {
-            this.stateDir = envStateDir.trim();
-            this.log('info', `Using state directory from PD_STATE_DIR: ${this.stateDir}`);
-            return this.stateDir;
-        }
-        // If workspaceDir was explicitly provided via constructor, use workspace-based state dir
-        // This ensures tests and programmatic usage don't get polluted by global config
-        if (this.initialized && this.workspaceDir) {
-            const pathApi = getPathApi(this.workspaceDir);
-            this.stateDir = pathApi.join(this.workspaceDir, '.state');
-            this.log('debug', `Using workspace-based state directory: ${this.stateDir}`);
-            return this.stateDir;
-        }
-        const fileConfig = loadConfigFromFile();
-        if (fileConfig?.state) {
-            this.stateDir = fileConfig.state;
-            this.log('info', `Using state directory from config file: ${this.stateDir}`);
-            return this.stateDir;
-        }
-        const workspaceDir = this.getWorkspaceDir();
-        const pathApi = getPathApi(workspaceDir);
-        this.stateDir = pathApi.join(workspaceDir, '.state');
-        this.log('debug', `Computed state directory: ${this.stateDir}`);
-        return this.stateDir;
-    }
-    resolve(key) {
-        const workspace = this.getWorkspaceDir();
-        const state = this.getStateDir();
-        const workspacePath = getPathApi(workspace);
-        const extensionRoot = PathResolver.extensionRoot || path.resolve(process.cwd(), 'packages', 'openclaw-plugin');
-        const extensionPath = getPathApi(extensionRoot);
-        const memory = workspacePath.join(workspace, 'memory');
-        const extensionSrc = extensionPath.join(extensionRoot, 'src');
-        const extensionDist = extensionPath.join(extensionRoot, 'dist');
-        const evolutionWorker = fs.existsSync(extensionSrc)
-            ? extensionPath.join(extensionSrc, 'service', 'evolution-worker.ts')
-            : extensionPath.join(extensionDist, 'service', 'evolution-worker.js');
-        const pathMap = {
-            'PROFILE': workspacePath.join(workspace, '.principles', 'PROFILE.json'),
-            'PRINCIPLES': workspacePath.join(workspace, '.principles', 'PRINCIPLES.md'),
-            'THINKING_OS': workspacePath.join(workspace, '.principles', 'THINKING_OS.md'),
-            'DECISION_POLICY': workspacePath.join(workspace, '.principles', 'DECISION_POLICY.json'),
-            'MODELS_DIR': workspacePath.join(workspace, '.principles', 'models'),
-            'AGENT_SCORECARD': workspacePath.join(state, 'AGENT_SCORECARD.json'),
-            'PAIN_FLAG': workspacePath.join(state, '.pain_flag'),
-            'EVOLUTION_QUEUE': workspacePath.join(state, 'evolution_queue.json'),
-            'EVOLUTION_DIRECTIVE': workspacePath.join(state, 'evolution_directive.json'),
-            'WORKBOARD': workspacePath.join(state, 'WORKBOARD.json'),
-            'SYSTEM_CAPABILITIES': workspacePath.join(state, 'SYSTEM_CAPABILITIES.json'),
-            'PAIN_SETTINGS': workspacePath.join(state, 'pain_settings.json'),
-            'PAIN_CANDIDATES': workspacePath.join(state, 'pain_candidates.json'),
-            'THINKING_OS_USAGE': workspacePath.join(state, 'thinking_os_usage.json'),
-            'DICTIONARY': workspacePath.join(state, 'pain_dictionary.json'),
-            'STATE_DIR': state,
-            'EXTENSION_ROOT': extensionRoot,
-            'EXTENSION_SRC': extensionSrc,
-            'EXTENSION_DIST': extensionDist,
-            'EVOLUTION_WORKER': evolutionWorker,
-            'LOGS': workspacePath.join(memory, 'logs'),
-            'SYSTEM_LOG': workspacePath.join(memory, 'logs', 'SYSTEM.log'),
-            'REFLECTION_LOG': workspacePath.join(memory, 'reflection-log.md'),
-            'USER_CONTEXT': workspacePath.join(memory, 'USER_CONTEXT.md'),
-            'OKR_DIR': workspacePath.join(memory, 'okr'),
-            'CURRENT_FOCUS': workspacePath.join(memory, 'okr', 'CURRENT_FOCUS.md'),
-            'WEEK_STATE': workspacePath.join(memory, 'okr', 'WEEK_STATE.json'),
-            'THINKING_OS_CANDIDATES': workspacePath.join(memory, 'THINKING_OS_CANDIDATES.md'),
-            'EVOLUTION_STREAM': workspacePath.join(memory, 'evolution.jsonl'),
-            'EVOLUTION_LOCK': workspacePath.join(memory, '.locks', 'evolution'),
-            'PRINCIPLE_BLACKLIST': workspacePath.join(state, 'principle_blacklist.json'),
-            'MEMORY': memory,
-        };
-        const resolved = pathMap[key];
-        if (!resolved) {
-            this.log('warn', `Unknown path key: ${key}`);
-            throw new PathResolutionError(key);
-        }
-        this.log('debug', `Resolved path for '${key}': ${resolved}`);
-        return resolved;
-    }
-    ensureStateDir() {
-        const stateDir = this.getStateDir();
-        if (!fs.existsSync(stateDir)) {
-            this.log('info', `Creating state directory: ${stateDir}`);
-            fs.mkdirSync(stateDir, { recursive: true });
-        }
-    }
-    static createFromHookContext(ctx) {
-        const resolver = new PathResolver();
-        if (ctx?.workspaceDir) {
-            let workspaceDir = String(ctx.workspaceDir);
-            if (resolver.normalizeWorkspace) {
-                workspaceDir = resolver.normalizePath(workspaceDir);
-            }
-            resolver.workspaceDir = workspaceDir;
-            resolver.initialized = true;
-            resolver.log('info', `Created from hook context with workspace: ${workspaceDir}`);
-        }
-        if (ctx?.stateDir) {
-            resolver.stateDir = String(ctx.stateDir);
-        }
-        return resolver;
-    }
-}
-export function createDefaultConfig(targetPath) {
-    const defaultConfig = {
-        workspace: path.join(os.homedir(), '.openclaw', 'workspace'),
-        state: path.join(os.homedir(), '.openclaw', 'workspace', '.state'),
-        debug: false,
-    };
-    const target = targetPath || path.join(os.homedir(), '.openclaw', PD_CONFIG_FILE);
-    const dir = path.dirname(target);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    atomicWriteFileSync(target, JSON.stringify(defaultConfig, null, 2));
-    console.log(`✅ Created default config at: ${target}`);
-    console.log(`   You can edit this file to customize paths.`);
-    return target;
-}
-// ── OpenClaw API Workspace Resolution ────────────────────────────
-/**
- * Resolve workspace directory via OpenClaw's official API.
- *
- * Replaces the removed `api.workspaceDir` field.
- *
- * Priority: api.runtime.agent.resolveAgentWorkspaceDir(agentId)
- *           → PathResolver.getWorkspaceDir() (PD env vars, config file, default)
- *
- * @param api - Plugin API instance
- * @param agentId - Agent ID (defaults to 'main' if not provided)
- * @returns Resolved workspace directory, or `undefined` if all resolution paths fail
- */
-export function resolveWorkspaceDirFromApi(api, agentId) {
-    if (!api)
-        return undefined;
-    // 1. Official API: api.runtime.agent.resolveAgentWorkspaceDir
-    const officialAgent = api.runtime.agent;
-    if (officialAgent?.resolveAgentWorkspaceDir) {
-        try {
-            return officialAgent.resolveAgentWorkspaceDir(api.config, agentId ?? 'main');
-        }
-        catch {
-            // Fall through to config check
-        }
-    }
-    // 2. Direct config workspaceDir (for tests and programmatic usage)
-    const cfgWorkspaceDir = api.config?.workspaceDir;
-    if (cfgWorkspaceDir && cfgWorkspaceDir.trim()) {
-        return cfgWorkspaceDir.trim();
-    }
-    // 3. Fallback: PathResolver (PD_WORKSPACE_DIR env, config file, default)
-    try {
-        const pr = new PathResolver();
-        return pr.getWorkspaceDir();
-    }
-    catch {
-        return undefined;
-    }
-}

package/plugin/dist/core/paths.js

@@ -1,77 +0,0 @@
-import * as path from 'path';
-const posixJoin = (...parts) => path.posix.join(...parts);
-function isWindowsPath(input) {
-    return /^[A-Za-z]:[\\/]/.test(input) || input.startsWith('\\\\');
-}
-function joinWorkspacePath(workspaceDir, relativePath) {
-    if (isWindowsPath(workspaceDir)) {
-        return path.win32.join(workspaceDir, relativePath);
-    }
-    if (workspaceDir.startsWith('/')) {
-        return path.posix.join(workspaceDir, relativePath);
-    }
-    return path.join(workspaceDir, relativePath);
-}
-/**
- * Principles Disciple Directory Constants
- * Establishing a logical separation between Identity, State, and Memory.
- */
-export const PD_DIRS = {
-    IDENTITY: '.principles',
-    MODELS: posixJoin('.principles', 'models'),
-    STATE: '.state',
-    MEMORY: 'memory',
-    OKR: posixJoin('memory', 'okr'),
-    LOGS: posixJoin('memory', 'logs'),
-    SESSIONS: posixJoin('.state', 'sessions'),
-    PAIN_SAMPLES: posixJoin('memory', 'pain'),
-    LOCKS: posixJoin('memory', '.locks'),
-    IMPL_CODE_DIR: posixJoin('.state', 'principles', 'implementations'),
-};
-/**
- * Standard File Path Mappings
- */
-export const PD_FILES = {
-    PROFILE: posixJoin(PD_DIRS.IDENTITY, 'PROFILE.json'),
-    PRINCIPLES: posixJoin(PD_DIRS.IDENTITY, 'PRINCIPLES.md'),
-    THINKING_OS: posixJoin(PD_DIRS.IDENTITY, 'THINKING_OS.md'),
-    DECISION_POLICY: posixJoin(PD_DIRS.IDENTITY, 'DECISION_POLICY.json'),
-    MODELS_DIR: PD_DIRS.MODELS,
-    STATE_DIR: PD_DIRS.STATE,
-    EVOLUTION_QUEUE: posixJoin(PD_DIRS.STATE, 'evolution_queue.json'),
-    EVOLUTION_DIRECTIVE: posixJoin(PD_DIRS.STATE, 'evolution_directive.json'),
-    WORKBOARD: posixJoin(PD_DIRS.STATE, 'WORKBOARD.json'),
-    AGENT_SCORECARD: posixJoin(PD_DIRS.STATE, 'AGENT_SCORECARD.json'),
-    PAIN_FLAG: posixJoin(PD_DIRS.STATE, '.pain_flag'),
-    SYSTEM_CAPABILITIES: posixJoin(PD_DIRS.STATE, 'SYSTEM_CAPABILITIES.json'),
-    PAIN_SETTINGS: posixJoin(PD_DIRS.STATE, 'pain_settings.json'),
-    PAIN_CANDIDATES: posixJoin(PD_DIRS.STATE, 'pain_candidates.json'),
-    THINKING_OS_USAGE: posixJoin(PD_DIRS.STATE, 'thinking_os_usage.json'),
-    TRAJECTORY_DB: posixJoin(PD_DIRS.STATE, 'trajectory.db'),
-    TRAJECTORY_BLOBS_DIR: posixJoin(PD_DIRS.STATE, 'blobs'),
-    EXPORTS_DIR: posixJoin(PD_DIRS.STATE, 'exports'),
-    SESSION_DIR: PD_DIRS.SESSIONS,
-    DICTIONARY: posixJoin(PD_DIRS.STATE, 'pain_dictionary.json'),
-    PRINCIPLE_BLACKLIST: posixJoin(PD_DIRS.STATE, 'principle_blacklist.json'),
-    WORKFLOWS_YAML: posixJoin(PD_DIRS.STATE, 'workflows.yaml'),
-    IMPL_CODE_DIR: PD_DIRS.IMPL_CODE_DIR,
-    MEMORY_MD: 'MEMORY.md',
-    HEARTBEAT: 'HEARTBEAT.md',
-    SYSTEM_LOG: posixJoin(PD_DIRS.LOGS, 'SYSTEM.log'),
-    REFLECTION_LOG: posixJoin(PD_DIRS.MEMORY, 'reflection-log.md'),
-    USER_CONTEXT: posixJoin(PD_DIRS.MEMORY, 'USER_CONTEXT.md'),
-    OKR_DIR: PD_DIRS.OKR,
-    CURRENT_FOCUS: posixJoin(PD_DIRS.OKR, 'CURRENT_FOCUS.md'),
-    WEEK_STATE: posixJoin(PD_DIRS.OKR, 'WEEK_STATE.json'),
-    THINKING_OS_CANDIDATES: posixJoin(PD_DIRS.MEMORY, 'THINKING_OS_CANDIDATES.md'),
-    // SEMANTIC_PAIN (confusion_samples.md) removed (PRI-451 Wave 1): the file
-    // had zero readers. The lifecycle write that populated it was also removed.
-    EVOLUTION_STREAM: posixJoin(PD_DIRS.MEMORY, 'evolution.jsonl'),
-    EVOLUTION_LOCK: posixJoin(PD_DIRS.LOCKS, 'evolution'),
-};
-/**
- * Resolves a PD file path within a given workspace.
- */
-export function resolvePdPath(workspaceDir, fileKey) {
-    return joinWorkspacePath(workspaceDir, PD_FILES[fileKey]);
-}