create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/pd-config-loader.js

@@ -1,307 +0,0 @@
-/**
- * PD Config Loader (Plugin I/O boundary) — PRI-307
- *
- * Reads `.pd/config.yaml`, validates via core, computes effective config.
- * Replaces the old `.pd/feature-flags.yaml` and `.state/workflows.yaml` reading
- * for plugin production paths.
- *
- * ADR-0016: PD owns exactly one user config file.
- * - Missing config → defaults with nextAction
- * - Malformed config → fail loud with errors and nextAction
- * - No secrets in output
- * - Observer disabled → no start / no noisy log cycling
- * - Observer enabled + missing setup → structured needs_setup + nextAction
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import { validatePdConfig, computeEffectivePdConfig, computeFeatureFlagsFromConfig, INTERNAL_AGENT_NAMES, } from '@principles/core/runtime-v2';
-// ── Constants ────────────────────────────────────────────────────────────────
-export const PD_CONFIG_DIR = '.pd';
-export const PD_CONFIG_FILENAME = 'config.yaml';
-// ── Config Path ──────────────────────────────────────────────────────────────
-export function getPdConfigPath(workspaceDir) {
-    return path.join(workspaceDir, PD_CONFIG_DIR, PD_CONFIG_FILENAME);
-}
-// ── Load PD Config ───────────────────────────────────────────────────────────
-/**
- * Load and validate `.pd/config.yaml` from the workspace.
- * Never throws on malformed input. Always provides a usable fallback.
- */
-export function loadPdConfigForPlugin(workspaceDir) {
-    const configPath = getPdConfigPath(workspaceDir);
-    // 1) Config file missing → use defaults
-    if (!fs.existsSync(configPath)) {
-        const effective = computeEffectivePdConfig(null);
-        return {
-            ok: true,
-            effective,
-            source: 'defaults',
-            configPath,
-            warnings: effective.warnings,
-            errors: [],
-        };
-    }
-    // 2) Read the file
-    let raw;
-    try {
-        raw = fs.readFileSync(configPath, 'utf8');
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const effective = computeEffectivePdConfig(null);
-        return {
-            ok: false,
-            effective,
-            source: 'malformed',
-            configPath,
-            warnings: [],
-            errors: [{ path: '', reason: `Failed to read .pd/config.yaml: ${message}`, nextAction: 'Check file permissions for .pd/config.yaml' }],
-        };
-    }
-    // 3) Parse YAML — treat as unknown (ERR-001)
-    let parsed;
-    try {
-        parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const effective = computeEffectivePdConfig(null);
-        return {
-            ok: false,
-            effective,
-            source: 'malformed',
-            configPath,
-            warnings: [],
-            errors: [{ path: '', reason: `YAML parse error in .pd/config.yaml: ${message}`, nextAction: 'Fix YAML syntax in .pd/config.yaml' }],
-        };
-    }
-    // 4) Validate via core (ERR-001, ERR-005: no `as` bypasses)
-    const validationResult = validatePdConfig(parsed);
-    if (!validationResult.ok) {
-        const effective = computeEffectivePdConfig(null);
-        return {
-            ok: false,
-            effective,
-            source: 'malformed',
-            configPath,
-            warnings: [],
-            errors: validationResult.errors.map(e => ({
-                path: e.path,
-                reason: e.reason,
-                nextAction: e.nextAction,
-            })),
-        };
-    }
-    // 5) Compute effective config
-    const effective = computeEffectivePdConfig(validationResult.value);
-    return {
-        ok: true,
-        effective,
-        source: 'user_config',
-        configPath,
-        warnings: effective.warnings,
-        errors: [],
-    };
-}
-// ── Feature Flag from Config ─────────────────────────────────────────────────
-/**
- * Get a single feature flag's enabled state from .pd/config.yaml.
- * Replaces the old `loadFeatureFlagFromWorkspace` which read .pd/feature-flags.yaml.
- */
-export function loadFeatureFlagFromConfig(workspaceDir, flagId, logger) {
-    const result = loadPdConfigForPlugin(workspaceDir);
-    const flags = computeFeatureFlagsFromConfig(result.effective);
-    const flag = flags.flags[flagId];
-    if (!result.ok) {
-        logger?.warn?.(`[PD:Config] Config validation failed: ${result.errors.map(e => e.reason).join('; ')} — using defaults`);
-    }
-    return {
-        enabled: flag?.enabled ?? false,
-        source: result.source,
-    };
-}
-// ── Observer Config Resolution ───────────────────────────────────────────────
-/**
- * Resolve observer configuration from .pd/config.yaml.
- *
- * Returns structured state:
- * - config_malformed: config file is invalid — no guessing, fail loud
- * - disabled: observer feature flag is off OR agent.enabled=false → no start, no noisy logs
- * - needs_setup: observer enabled but runtime profile missing, API key not set, or unsupported profile type
- * - ready: observer enabled and fully configured (pi-ai with key present)
- * - not_ready: observer enabled, API key present, but runtime availability unknown
- */
-export function resolveObserverConfig(workspaceDir, observerFlagId, observerAgentName, _logger) {
-    const result = loadPdConfigForPlugin(workspaceDir);
-    // 0) Malformed config → fail loud, do NOT swallow as "disabled"
-    if (!result.ok) {
-        return {
-            enabled: false,
-            readiness: 'config_malformed',
-            source: 'malformed',
-            reason: `Config validation failed: ${result.errors.map(e => e.reason).join('; ')}`,
-            nextAction: result.errors[0]?.nextAction ?? 'Fix .pd/config.yaml and retry',
-            runtimeProfileId: null,
-            runtimeProfileType: null,
-            apiKeyEnv: null,
-            apiKeyPresent: false,
-            provider: null,
-            model: null,
-            timeoutMs: null,
-            baseUrl: null,
-            configErrors: result.errors,
-        };
-    }
-    const config = result.effective.config;
-    // 1) Check if the observer feature flag is enabled
-    const featureFlag = config.features[observerFlagId];
-    if (!featureFlag || !featureFlag.enabled) {
-        return {
-            enabled: false,
-            readiness: 'disabled',
-            source: result.source,
-            reason: `${observerFlagId} is disabled in .pd/config.yaml`,
-            nextAction: `Set features.${observerFlagId}.enabled=true in .pd/config.yaml to enable`,
-            runtimeProfileId: null,
-            runtimeProfileType: null,
-            apiKeyEnv: null,
-            apiKeyPresent: false,
-            provider: null,
-            model: null,
-            timeoutMs: null,
-            baseUrl: null,
-        };
-    }
-    // 2) Check if the agent itself is enabled (feature flag ≠ agent.enabled)
-    const knownNames = INTERNAL_AGENT_NAMES;
-    if (!knownNames.includes(observerAgentName)) {
-        return {
-            enabled: false,
-            readiness: 'needs_setup',
-            source: result.source,
-            reason: `Unknown agent name '${observerAgentName}'`,
-            nextAction: `Use one of the known agent names: ${INTERNAL_AGENT_NAMES.join(', ')}`,
-            runtimeProfileId: null,
-            runtimeProfileType: null,
-            apiKeyEnv: null,
-            apiKeyPresent: false,
-            provider: null,
-            model: null,
-            timeoutMs: null,
-            baseUrl: null,
-        };
-    }
-    const agentKey = observerAgentName;
-    const agentConfig = config.internalAgents.agents[agentKey];
-    // Feature flag on but agent.enabled=false → disabled (not enabled)
-    if (!agentConfig || !agentConfig.enabled) {
-        return {
-            enabled: false,
-            readiness: 'disabled',
-            source: result.source,
-            reason: `${observerFlagId} feature flag is enabled but internalAgents.agents.${observerAgentName}.enabled is false`,
-            nextAction: `Set internalAgents.agents.${observerAgentName}.enabled=true in .pd/config.yaml, or disable features.${observerFlagId}`,
-            runtimeProfileId: null,
-            runtimeProfileType: null,
-            apiKeyEnv: null,
-            apiKeyPresent: false,
-            provider: null,
-            model: null,
-            timeoutMs: null,
-            baseUrl: null,
-        };
-    }
-    // 3) Find the agent's runtime profile
-    const runtimeProfileId = agentConfig.runtimeProfile ?? config.internalAgents.defaultRuntime;
-    const profile = config.runtimeProfiles[runtimeProfileId];
-    if (!profile) {
-        return {
-            enabled: true,
-            readiness: 'needs_setup',
-            source: result.source,
-            reason: `Runtime profile '${runtimeProfileId}' not found in .pd/config.yaml`,
-            nextAction: `Add runtime profile '${runtimeProfileId}' to .pd/config.yaml runtimeProfiles`,
-            runtimeProfileId,
-            runtimeProfileType: null,
-            apiKeyEnv: null,
-            apiKeyPresent: false,
-            provider: null,
-            model: null,
-            timeoutMs: null,
-            baseUrl: null,
-        };
-    }
-    // 4) For pi-ai profiles, check API key
-    if (profile.type === 'pi-ai') {
-        const apiKeyEnv = profile.apiKeyEnv ?? null;
-        const apiKeyPresent = !!apiKeyEnv && Object.prototype.hasOwnProperty.call(process.env, apiKeyEnv) && !!process.env[apiKeyEnv];
-        if (!apiKeyEnv) {
-            return {
-                enabled: true,
-                readiness: 'needs_setup',
-                source: result.source,
-                reason: `pi-ai profile '${runtimeProfileId}' missing apiKeyEnv`,
-                nextAction: `Add apiKeyEnv to runtime profile '${runtimeProfileId}' in .pd/config.yaml`,
-                runtimeProfileId,
-                runtimeProfileType: profile.type,
-                apiKeyEnv: null,
-                apiKeyPresent: false,
-                provider: profile.provider ?? null,
-                model: profile.model ?? null,
-                timeoutMs: profile.timeoutMs ?? null,
-                baseUrl: profile.baseUrl ?? null,
-            };
-        }
-        if (!apiKeyPresent) {
-            return {
-                enabled: true,
-                readiness: 'needs_setup',
-                source: result.source,
-                reason: `Environment variable '${apiKeyEnv}' is not set or empty`,
-                nextAction: `Set the environment variable '${apiKeyEnv}' with a valid API key`,
-                runtimeProfileId,
-                runtimeProfileType: profile.type,
-                apiKeyEnv,
-                apiKeyPresent: false,
-                provider: profile.provider ?? null,
-                model: profile.model ?? null,
-                timeoutMs: profile.timeoutMs ?? null,
-                baseUrl: profile.baseUrl ?? null,
-            };
-        }
-        // pi-ai with key present — runtime availability unknown without actual probe
-        return {
-            enabled: true,
-            readiness: 'not_ready',
-            source: result.source,
-            reason: `pi-ai profile configured with apiKeyEnv='${apiKeyEnv}' (key present); runtime availability unknown`,
-            nextAction: 'Run pd runtime probe to verify end-to-end connectivity',
-            runtimeProfileId,
-            runtimeProfileType: profile.type,
-            apiKeyEnv,
-            apiKeyPresent: true,
-            provider: profile.provider ?? null,
-            model: profile.model ?? null,
-            timeoutMs: profile.timeoutMs ?? null,
-            baseUrl: profile.baseUrl ?? null,
-        };
-    }
-    // 5) OpenClaw profile — CorrectionObserver does NOT support OpenClaw runtime
-    //    Mark as needs_setup with nextAction to configure a pi-ai profile
-    return {
-        enabled: true,
-        readiness: 'needs_setup',
-        source: result.source,
-        reason: `OpenClaw profile '${runtimeProfileId}' is not supported for observer runtime. Observers require a pi-ai profile with an API key.`,
-        nextAction: `Configure a pi-ai runtime profile for ${observerAgentName} in .pd/config.yaml (e.g., add a pi-ai profile with provider, model, and apiKeyEnv)`,
-        runtimeProfileId,
-        runtimeProfileType: profile.type,
-        apiKeyEnv: null,
-        apiKeyPresent: false,
-        provider: profile.provider ?? null,
-        model: profile.model ?? null,
-        timeoutMs: null,
-        baseUrl: null,
-    };
-}

package/plugin/dist/core/pd-task-reconciler.js

@@ -1,262 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { BUILTIN_PD_TASKS } from './pd-task-types.js';
-import { readTasks, writeTasks } from './pd-task-store.js';
-import { withLockAsync } from '../utils/file-lock.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-const CRON_STORE_PATH = path.join(os.homedir(), '.openclaw', 'cron', 'jobs.json');
-function readCronStore(logger) {
-    if (!fs.existsSync(CRON_STORE_PATH)) {
-        logger?.info?.(`[PD:Reconciler] cron/jobs.json not found, starting with empty store`);
-        return { version: 1, jobs: [] };
-    }
-    try {
-        const raw = fs.readFileSync(CRON_STORE_PATH, 'utf-8');
-        const store = JSON.parse(raw);
-        logger?.info?.(`[PD:Reconciler] Loaded cron/jobs.json: ${store.jobs.length} jobs`);
-        return store;
-    }
-    catch (err) {
-        logger?.warn?.(`[PD:Reconciler] Failed to parse cron/jobs.json: ${String(err)}`);
-        return { version: 1, jobs: [] };
-    }
-}
-async function writeCronStore(store) {
-    await withLockAsync(CRON_STORE_PATH, async () => {
-        atomicWriteFileSync(CRON_STORE_PATH, JSON.stringify(store, null, 2));
-    });
-}
-function diff(declared, actual) {
-    const actions = [];
-    const actualByName = new Map();
-    for (const job of actual) {
-        actualByName.set(job.name, job);
-    }
-    for (const task of declared) {
-        const job = actualByName.get(task.name);
-        if (!job) {
-            if (task.enabled) {
-                actions.push({ type: 'CREATE', task });
-            }
-        }
-        else {
-            const pdVersion = job.metadata?.pdVersion;
-            if (!task.enabled) {
-                actions.push({ type: 'DISABLE', task, job });
-            }
-            else if (!pdVersion || pdVersion !== task.version) {
-                actions.push({ type: 'UPDATE', task, job });
-            }
-            else {
-                actions.push({ type: 'SKIP', task, job });
-            }
-        }
-    }
-    for (const job of actual) {
-        if (!job.name.startsWith('PD '))
-            continue;
-        const found = declared.find((t) => t.name === job.name);
-        if (!found) {
-            actions.push({ type: 'ORPHAN', job });
-        }
-    }
-    return actions;
-}
-function buildCronJob(task, nowMs, workspaceDir, logger) {
-    logger?.info?.(`[PD:Reconciler] Building cron job: ${task.name} (id=${task.id}, interval=${task.schedule.everyMs}ms)`);
-    return {
-        id: `pd-${task.id}-${nowMs}`,
-        name: task.name,
-        agentId: task.agentId || 'main',
-        description: task.description,
-        enabled: task.enabled,
-        schedule: { kind: 'every', everyMs: task.schedule.everyMs },
-        sessionTarget: 'isolated',
-        wakeMode: 'now',
-        payload: {
-            kind: 'agentTurn',
-            message: buildTaskPrompt(task, workspaceDir, logger),
-            lightContext: task.execution.lightContext ?? true,
-            timeoutSeconds: task.execution.timeoutSeconds ?? 120,
-            toolsAllow: task.execution.toolsAllow,
-        },
-        delivery: { mode: task.delivery.mode },
-        createdAtMs: nowMs,
-        updatedAtMs: nowMs,
-        state: {
-            nextRunAtMs: nowMs + task.schedule.everyMs,
-        },
-        metadata: {
-            pdVersion: task.version,
-            pdTaskId: task.id,
-        },
-    };
-}
-function buildTaskPrompt(task, _workspaceDir, _logger) {
-    return task.description;
-}
-export async function reconcilePDTasks(workspaceDir, options) {
-    const dryRun = options?.dryRun ?? false;
-    const logger = options?.logger ?? console;
-    const nowMs = Date.now();
-    const result = { created: [], updated: [], skipped: [], orphaned: [], errors: [] };
-    const storedTasks = readTasks(workspaceDir);
-    const storedById = new Map(storedTasks.map((t) => [t.id, t]));
-    const declared = BUILTIN_PD_TASKS.map((t) => {
-        const stored = storedById.get(t.id);
-        if (stored) {
-            return { ...t, meta: { ...t.meta, ...stored.meta } };
-        }
-        return { ...t, meta: { createdAtMs: nowMs } };
-    });
-    const cronStore = await readCronStore(logger);
-    const healthUpdated = healthCheck(declared, cronStore, logger);
-    const actions = diff(healthUpdated, cronStore.jobs);
-    for (const action of actions) {
-        switch (action.type) {
-            case 'CREATE':
-                if (action.task) {
-                    if (!dryRun) {
-                        const job = buildCronJob(action.task, nowMs, workspaceDir, logger);
-                        cronStore.jobs.push(job);
-                        logger.info?.(`[PD:Reconciler] Created job: ${action.task.name}`);
-                    }
-                    result.created.push(action.task.name);
-                }
-                break;
-            case 'UPDATE':
-                if (action.task && action.job) {
-                    if (!dryRun) {
-                        const idx = cronStore.jobs.indexOf(action.job);
-                        const newJob = buildCronJob(action.task, nowMs, workspaceDir, logger);
-                        newJob.id = action.job.id;
-                        // Preserve original state — only CronService should recalculate nextRunAtMs
-                        newJob.state = {
-                            ...action.job.state,
-                            nextRunAtMs: undefined, // Let CronService recalculate
-                        };
-                        cronStore.jobs[idx] = newJob;
-                        logger.info?.(`[PD:Reconciler] Updated job: ${action.task.name}`);
-                    }
-                    result.updated.push(action.task.name);
-                }
-                break;
-            case 'DISABLE':
-                if (action.job) {
-                    if (!dryRun) {
-                        const idx = cronStore.jobs.indexOf(action.job);
-                        if (idx >= 0) {
-                            cronStore.jobs[idx] = { ...action.job, enabled: false, updatedAtMs: nowMs };
-                        }
-                    }
-                    logger.warn?.(`[PD:Reconciler] Disabled job: ${action.job.name}`);
-                }
-                break;
-            case 'ORPHAN':
-                if (action.job) {
-                    logger.warn?.(`[PD:Reconciler] Orphaned job (no declaration): ${action.job.name}`);
-                    result.orphaned.push(action.job.name);
-                }
-                break;
-            case 'SKIP':
-                if (action.task) {
-                    result.skipped.push(action.task.name);
-                }
-                break;
-        }
-    }
-    if (!dryRun && (result.created.length > 0 || result.updated.length > 0)) {
-        await writeCronStore(cronStore);
-        logger.info?.(`[PD:Reconciler] Wrote cron/jobs.json: ${cronStore.jobs.length} total jobs`);
-        for (const job of cronStore.jobs) {
-            if (job.name.startsWith('PD ')) {
-                logger.info?.(`[PD:Reconciler] PD job: name=${job.name}, enabled=${job.enabled}, schedule=${JSON.stringify(job.schedule)}, nextRun=${job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString() : 'TBD'}`);
-            }
-        }
-    }
-    if (!dryRun && declared.length > 0) {
-        await writeTasks(workspaceDir, declared);
-    }
-    return result;
-}
-function healthCheck(tasks, cronStore, logger) {
-    const jobByName = new Map(cronStore.jobs.map((j) => [j.name, j]));
-    return tasks.map((task) => {
-        const job = jobByName.get(task.name);
-        if (!job)
-            return task;
-        const errors = job.state.consecutiveErrors ?? 0;
-        const lastError = job.state.lastError ?? '';
-        const isTimeout = lastError.includes('timed out') || lastError.includes('timeout');
-        // Auto-increase timeout on timeout error (exponential backoff: 2x, max 1800s)
-        if (isTimeout && errors > 0 && job.payload.kind === 'agentTurn') {
-            const currentTimeout = job.payload.timeoutSeconds ?? 120;
-            const newTimeout = Math.min(1800, currentTimeout * 2);
-            if (newTimeout > currentTimeout) {
-                job.payload.timeoutSeconds = newTimeout;
-                job.state.consecutiveErrors = 0;
-                job.state.lastError = undefined;
-                logger.info?.(`[PD:Reconciler] Auto-increased timeout for '${task.name}': ${currentTimeout}s → ${newTimeout}s (was ${errors} consecutive timeouts)`);
-            }
-        }
-        // Auto-disable only for non-timeout errors after 3 consecutive failures
-        const shouldAutoDisable = errors >= 3 && !isTimeout && !task.meta?.autoDisabled;
-        // Reset consecutiveErrors on non-error runs
-        if (errors === 0 && task.meta?.autoDisabled) {
-            logger.info?.(`[PD:Reconciler] Task '${task.id}' was previously auto-disabled but has 0 consecutive errors now`);
-        }
-        if (shouldAutoDisable || task.meta || job.state.lastRunAtMs) {
-            return {
-                ...task,
-                meta: {
-                    ...task.meta,
-                    ...(shouldAutoDisable ? {
-                        autoDisabled: true,
-                        autoDisabledAt: Date.now(),
-                        autoDisabledReason: `consecutiveErrors=${errors}`,
-                    } : {}),
-                    ...(task.meta ? { consecutiveFailCount: errors } : {}),
-                    ...(job.state.lastRunAtMs ? { lastFailedAtMs: job.state.lastRunAtMs } : {}),
-                },
-            };
-        }
-        return task;
-    });
-}
-export async function trigger(taskId, workspaceDir, options) {
-    const tasks = readTasks(workspaceDir);
-    const task = tasks.find((t) => t.id === taskId);
-    if (!task) {
-        return { ok: false, error: `Task '${taskId}' not found` };
-    }
-    if (task.meta?.autoDisabled && !options?.force) {
-        return { ok: false, error: 'Task is auto-disabled. Use force=true to override.' };
-    }
-    const log = (msg) => console.info(`[PD:Trigger] ${msg}`);
-    const cronStore = await readCronStore({ info: log, warn: log });
-    const nowMs = Date.now();
-    const existingJob = cronStore.jobs.find((j) => j.name === task.name);
-    if (existingJob) {
-        log(`Manually triggering existing job: ${task.name} (id=${existingJob.id})`);
-        existingJob.enabled = true;
-        existingJob.updatedAtMs = nowMs;
-        existingJob.state.nextRunAtMs = nowMs;
-        existingJob.deleteAfterRun = undefined;
-    }
-    else {
-        log(`Creating new job for manual trigger: ${task.name}`);
-        const newJob = buildCronJob(task, nowMs, workspaceDir, { info: log });
-        newJob.enabled = true;
-        newJob.state.nextRunAtMs = nowMs;
-        cronStore.jobs.push(newJob);
-    }
-    if (!task.meta)
-        task.meta = {};
-    task.meta.lastTriggeredAtMs = nowMs;
-    task.meta.lastTriggerStatus = 'pending';
-    await writeCronStore(cronStore);
-    await writeTasks(workspaceDir, tasks);
-    log(`Trigger complete: nextRunAt=${nowMs}, will run on next cron cycle`);
-    return { ok: true };
-}

package/plugin/dist/core/pd-task-service.js

@@ -1,32 +0,0 @@
-import { reconcilePDTasks } from './pd-task-reconciler.js';
-export const PDTaskService = {
-    id: 'principles-disciple-task-manager',
-    async start(ctx) {
-        const { workspaceDir } = ctx;
-        const logger = ctx.logger ?? ctx.api?.logger;
-        if (!workspaceDir) {
-            logger?.warn?.(`[PD:TaskManager] No workspaceDir, skipping PD task reconciliation`);
-            return;
-        }
-        logger?.info?.(`[PD:TaskManager] Starting PD task reconciliation...`);
-        try {
-            const result = await reconcilePDTasks(workspaceDir, { logger: logger ?? console });
-            logger?.info?.(`[PD:TaskManager] Reconcile complete: +${result.created.length} ~${result.updated.length} =${result.skipped.length} orphan=${result.orphaned.length}`);
-            if (result.created.length > 0) {
-                logger?.info?.(`[PD:TaskManager] Created jobs: ${result.created.join(', ')}`);
-            }
-            if (result.updated.length > 0) {
-                logger?.info?.(`[PD:TaskManager] Updated jobs: ${result.updated.join(', ')}`);
-            }
-            if (result.errors.length > 0) {
-                logger?.warn?.(`[PD:TaskManager] Reconcile errors: ${result.errors.map((e) => e.message).join(', ')}`);
-            }
-        }
-        catch (err) {
-            logger?.warn?.(`[PD:TaskManager] Reconcile failed: ${String(err)}`);
-        }
-    },
-    stop(_ctx) {
-        /* intentionally empty - no cleanup required for this service */
-    },
-};

package/plugin/dist/core/pd-task-store.js

@@ -1,62 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { withLockAsync } from '../utils/file-lock.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-const PD_TASKS_FILENAME = 'pd_tasks.json';
-function resolvePdTasksPath(workspaceDir) {
-    return path.join(workspaceDir, '.state', PD_TASKS_FILENAME);
-}
-function ensureStateDir(workspaceDir) {
-    const stateDir = path.join(workspaceDir, '.state');
-    if (!fs.existsSync(stateDir)) {
-        fs.mkdirSync(stateDir, { recursive: true });
-    }
-}
-export function readTasks(workspaceDir) {
-    const filePath = resolvePdTasksPath(workspaceDir);
-    if (!fs.existsSync(filePath)) {
-        return [];
-    }
-    try {
-        const raw = fs.readFileSync(filePath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (Array.isArray(parsed)) {
-            return parsed;
-        }
-        return [];
-    }
-    catch (err) {
-        console.warn(`[PD:TaskStore] Failed to parse ${PD_TASKS_FILENAME}: ${String(err)}`);
-        return [];
-    }
-}
-export async function writeTasks(workspaceDir, tasks) {
-    const filePath = resolvePdTasksPath(workspaceDir);
-    ensureStateDir(workspaceDir);
-    await withLockAsync(filePath, async () => {
-        atomicWriteFileSync(filePath, JSON.stringify(tasks, null, 2));
-    });
-}
-export function initTaskMeta(task) {
-    if (!task.meta) {
-        task.meta = {};
-    }
-    if (!task.meta.createdAtMs) {
-        task.meta.createdAtMs = Date.now();
-    }
-    return task;
-}
-export function updateSyncMeta(task, status, jobId, error) {
-    if (!task.meta) {
-        task.meta = {};
-    }
-    task.meta.lastSyncedAtMs = Date.now();
-    task.meta.lastSyncStatus = status;
-    if (jobId) {
-        task.meta.lastSyncedJobId = jobId;
-    }
-    if (error) {
-        task.meta.lastSyncError = error;
-    }
-    return task;
-}

package/plugin/dist/core/pd-task-types.js

@@ -1,2 +0,0 @@
-export { PDTaskScheduleSchema, PDTaskExecutionSchema, PDTaskDeliverySchema, PDTaskMetaSchema, PDTaskSpecSchema, } from '@principles/core/runtime-v2';
-export const BUILTIN_PD_TASKS = [];