principles-disciple 1.126.0 → 1.128.0

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

@@ -0,0 +1,307 @@
+/**
+ * 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 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/dist/core/pd-task-reconciler.d.ts

@@ -0,0 +1,89 @@
+import type { PDTaskSpec } from './pd-task-types.js';
+export interface CronJobState {
+    nextRunAtMs?: number;
+    runningAtMs?: number;
+    lastRunAtMs?: number;
+    lastRunStatus?: string;
+    lastStatus?: 'ok' | 'error' | 'skipped';
+    lastError?: string;
+    lastDurationMs?: number;
+    consecutiveErrors?: number;
+}
+export interface CronJob {
+    id: string;
+    name: string;
+    agentId?: string;
+    description?: string;
+    enabled: boolean;
+    deleteAfterRun?: boolean;
+    createdAtMs: number;
+    updatedAtMs: number;
+    schedule: {
+        kind: 'every';
+        everyMs: number;
+    } | {
+        kind: 'at';
+        at: string;
+    } | {
+        kind: 'cron';
+        expr: string;
+        tz?: string;
+    };
+    sessionTarget: string;
+    wakeMode: string;
+    payload: {
+        kind: 'systemEvent';
+        text: string;
+    } | {
+        kind: 'agentTurn';
+        message: string;
+        model?: string;
+        thinking?: string;
+        timeoutSeconds?: number;
+        lightContext?: boolean;
+        toolsAllow?: string[];
+    };
+    delivery?: {
+        mode: string;
+        channel?: string;
+        to?: string;
+    };
+    state: CronJobState;
+    metadata?: Record<string, string>;
+}
+export interface CronStoreFile {
+    version: number;
+    jobs: CronJob[];
+}
+export type DiffActionType = 'CREATE' | 'UPDATE' | 'DISABLE' | 'ORPHAN' | 'SKIP';
+export interface DiffAction {
+    type: DiffActionType;
+    task?: PDTaskSpec;
+    job?: CronJob;
+}
+export interface ReconcileError {
+    taskId: string;
+    message: string;
+}
+export interface ReconcileResult {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+    orphaned: string[];
+    errors: ReconcileError[];
+}
+export interface ReconcileOptions {
+    dryRun?: boolean;
+    workspaceDir: string;
+    logger?: {
+        info?: (_: string) => void;
+        warn?: (_: string) => void;
+    };
+}
+export declare function reconcilePDTasks(workspaceDir: string, options?: Partial<ReconcileOptions>): Promise<ReconcileResult>;
+export declare function trigger(taskId: string, workspaceDir: string, options?: {
+    force?: boolean;
+}): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

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

@@ -0,0 +1,262 @@
+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/dist/core/pd-task-service.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginService } from '../openclaw-sdk.js';
+export declare const PDTaskService: OpenClawPluginService;

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

@@ -0,0 +1,32 @@
+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 */
+    },
+};