create-principles-disciple 1.86.0 → 1.87.0

package/plugin/dist/service/internalization-auto-consumer-service.js

@@ -0,0 +1,322 @@
+import { createRuntimeStateHandle, InternalizationOrchestrator, DreamerRunner, DefaultDreamerValidator, PiAiRuntimeAdapter, L2AgentLoopAdapter, buildL2PrincipleReaderFromLedger, loadLedger, OpenClawCliRuntimeAdapter, storeEmitter, resolveRuntimeConfigFromPdConfig, isRuntimeConfigError, computeConsumerDecision, InternalizationQueueReadModel, MVP_CORE_TASK_KINDS, } from '@principles/core/runtime-v2';
+import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { SystemLogger } from '../core/system-logger.js';
+const INTERNALIZATION_AUTO_CONSUMER_INTERVAL_MS = 120_000;
+const INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS = 30_000;
+const INTERNALIZATION_AUTO_CONSUMER_FLAG_ID = 'internalization_auto_consumer';
+const workspaceStates = new Map();
+function getWorkspaceState(workspaceDir) {
+    let state = workspaceStates.get(workspaceDir);
+    if (!state) {
+        state = { stopped: false, timeoutId: null };
+        workspaceStates.set(workspaceDir, state);
+    }
+    return state;
+}
+function formatRunOnceCommand(workspaceDir) {
+    return `pd runtime internalization run-once --workspace "${workspaceDir}" --runner dreamer --runtime config --json`;
+}
+function getNextActionForError(category) {
+    if (category === 'lease_conflict') {
+        return 'Retry later or check for concurrent worker processes.';
+    }
+    if (category === 'timeout') {
+        return 'Check model provider service status/latency, or increase timeout settings in workflows.yaml.';
+    }
+    if (category === 'cancelled') {
+        return 'Re-enqueue or restart the task if it was cancelled by mistake.';
+    }
+    if (category === 'output_invalid') {
+        return 'Verify if model outputs conform to expected schema and adjust prompt or validation templates if needed.';
+    }
+    if (category === 'input_invalid') {
+        return 'Check predecessor task outputs and database integrity for malformed input references.';
+    }
+    if (category === 'max_attempts_exceeded') {
+        return 'Investigate persistent failures, correct the root issue, and clear last_error or reset attempt count.';
+    }
+    return 'Run: pd runtime internalization run-once --runner dreamer --runtime config --json to isolate the failure.';
+}
+export async function runConsumerCycle(workspaceDir, logger) {
+    const flag = loadFeatureFlagFromConfig(workspaceDir, INTERNALIZATION_AUTO_CONSUMER_FLAG_ID, {
+        info: (msg) => logger.info(msg),
+        warn: (msg) => logger.warn(msg),
+    });
+    if (!flag.enabled) {
+        const disabledInfo = JSON.stringify({
+            reason: 'internalization_auto_consumer_disabled',
+            nextAction: formatRunOnceCommand(workspaceDir),
+            flagSource: flag.source,
+        });
+        SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', disabledInfo);
+        logger.info(`[PD:AutoConsumer] Cycle skipped: auto-consumer disabled. Source: ${flag.source}`);
+        return;
+    }
+    const configResult = loadPdConfigForPlugin(workspaceDir);
+    if (!configResult.ok) {
+        const malformedInfo = JSON.stringify({
+            reason: 'config_malformed',
+            nextAction: configResult.errors[0]?.nextAction ?? 'Fix .pd/config.yaml and retry',
+            errors: configResult.errors.map((e) => e.reason),
+        });
+        SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', malformedInfo);
+        logger.warn(`[PD:AutoConsumer] Config malformed, skipping cycle.`);
+        return;
+    }
+    const runtimeConfigResult = resolveRuntimeConfigFromPdConfig(configResult.effective, (name) => process.env[name]);
+    if (isRuntimeConfigError(runtimeConfigResult)) {
+        const rtInfo = JSON.stringify({
+            reason: 'runtime_config_error',
+            message: runtimeConfigResult.message,
+            nextAction: runtimeConfigResult.nextAction,
+        });
+        SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', rtInfo);
+        logger.warn(`[PD:AutoConsumer] Runtime config error: ${runtimeConfigResult.message}`);
+        return;
+    }
+    let handle = null;
+    try {
+        handle = await createRuntimeStateHandle({ workspaceDir, readonly: false });
+        const { stateManager } = handle;
+        const readModel = new InternalizationQueueReadModel(stateManager);
+        readModel.setPolicy({
+            enabledChannels: new Set(['prompt', 'code_tool_hook', 'defer_archive']),
+            actionableTaskKinds: new Set(MVP_CORE_TASK_KINDS),
+        });
+        const snapshot = await readModel.getSnapshot();
+        if (snapshot.readyTasks.length > 5) {
+            logger.warn(`[PD:AutoConsumer] Backlog detected: ${snapshot.readyTasks.length} tasks ready. Processing only one task.`);
+        }
+        const decision = computeConsumerDecision({
+            autoConsumerEnabled: true,
+            readyTaskCount: snapshot.readyTasks.length,
+        });
+        if (!decision.shouldConsume) {
+            SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', JSON.stringify({
+                reason: decision.reason,
+                readyTaskCount: snapshot.readyTasks.length,
+            }));
+            return;
+        }
+        const runtimeKind = runtimeConfigResult.runtimeKind;
+        const orchestrator = new InternalizationOrchestrator({ stateManager }, { owner: 'auto-consumer', runtimeKind, dryRun: true });
+        const wakeResult = await orchestrator.wakeOnce('dreamer');
+        if (wakeResult.decision !== 'would_lease') {
+            const skipPayload = {
+                decision: wakeResult.decision,
+            };
+            if (wakeResult.decision === 'no_ready_tasks') {
+                skipPayload.reason = wakeResult.reason;
+            }
+            SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SKIP', JSON.stringify(skipPayload));
+            logger.info(`[PD:AutoConsumer] No task to consume: ${wakeResult.decision}`);
+            return;
+        }
+        let adapter;
+        if (runtimeKind === 'pi-ai') {
+            // PRI-419: when l2_dreamer flag is on, route through the L2 multi-turn agent loop.
+            const l2Flag = loadFeatureFlagFromConfig(workspaceDir, 'l2_dreamer');
+            if (l2Flag.enabled) {
+                const stateDir = `${workspaceDir}/.state`;
+                const principleReader = buildL2PrincipleReaderFromLedger(loadLedger(stateDir), {
+                    logger: { warn: (msg) => logger.warn(msg) },
+                });
+                adapter = new L2AgentLoopAdapter({
+                    provider: runtimeConfigResult.provider ?? 'openai',
+                    model: runtimeConfigResult.model ?? 'gpt-4o',
+                    apiKeyEnv: runtimeConfigResult.apiKeyEnv ?? 'OPENAI_API_KEY',
+                    baseUrl: runtimeConfigResult.baseUrl,
+                    workspace: workspaceDir,
+                    totalBudgetMs: runtimeConfigResult.timeoutMs,
+                }, {
+                    artifactReader: {
+                        // Explicit adapter: PIArtifactRecord → PdL2ArtifactReader. The store returns
+                        // PIArtifactRecord (with PIArtifactKind enum); map to the ArtifactSummary shape.
+                        getArtifactById: async (id) => {
+                            const r = await stateManager.piArtifactStore.getArtifactById(id);
+                            return r ? { artifactId: r.artifactId, artifactKind: String(r.artifactKind), sourceTaskId: r.sourceTaskId, contentJson: r.contentJson, createdAt: r.createdAt } : null;
+                        },
+                        listBySourceTaskId: async (taskId) => {
+                            const records = await stateManager.piArtifactStore.listBySourceTaskId(taskId);
+                            return records.map(r => ({ artifactId: r.artifactId, artifactKind: String(r.artifactKind), sourceTaskId: r.sourceTaskId, contentJson: r.contentJson, createdAt: r.createdAt }));
+                        },
+                    },
+                    principleReader,
+                });
+            }
+            else {
+                adapter = new PiAiRuntimeAdapter({
+                    provider: runtimeConfigResult.provider ?? 'openai',
+                    model: runtimeConfigResult.model ?? 'gpt-4o',
+                    apiKeyEnv: runtimeConfigResult.apiKeyEnv ?? 'OPENAI_API_KEY',
+                    maxRetries: runtimeConfigResult.maxRetries,
+                    timeoutMs: runtimeConfigResult.timeoutMs,
+                    baseUrl: runtimeConfigResult.baseUrl,
+                    workspace: workspaceDir,
+                });
+            }
+        }
+        else if (runtimeKind === 'openclaw-cli') {
+            adapter = new OpenClawCliRuntimeAdapter({
+                runtimeMode: runtimeConfigResult.openclawMode ?? 'default',
+                workspaceDir: workspaceDir,
+            });
+        }
+        else {
+            throw new Error(`Unsupported runtime kind resolved for auto-consumer: ${runtimeKind}`);
+        }
+        const validator = new DefaultDreamerValidator();
+        const runner = new DreamerRunner({
+            stateManager,
+            runtimeAdapter: adapter,
+            eventEmitter: storeEmitter,
+            artifactStore: stateManager.piArtifactStore,
+            validator,
+        }, {
+            owner: 'auto-consumer',
+            runtimeKind,
+        });
+        const taskId = wakeResult.taskId;
+        logger.info(`[PD:AutoConsumer] Running dreamer task: ${taskId}`);
+        SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_RUN', JSON.stringify({
+            taskId,
+            taskKind: 'dreamer',
+        }));
+        let runResult;
+        try {
+            runResult = await runner.run(taskId);
+        }
+        catch (runErr) {
+            logger.error(`[PD:AutoConsumer] Runner crashed for task ${taskId}: ${String(runErr)}`);
+            try {
+                const task = await stateManager.getTask(taskId);
+                const failureReason = `Unhandled runner exception: ${runErr instanceof Error ? runErr.message : String(runErr)}`;
+                if (task && stateManager.getRetryPolicy().shouldRetry(task)) {
+                    await stateManager.markTaskRetryWait(taskId, 'execution_failed', failureReason);
+                    logger.info(`[PD:AutoConsumer] Marked task ${taskId} as retry_wait.`);
+                }
+                else {
+                    await stateManager.markTaskFailed(taskId, 'execution_failed', failureReason);
+                    logger.info(`[PD:AutoConsumer] Marked task ${taskId} as failed.`);
+                }
+            }
+            catch (dbErr) {
+                logger.error(`[PD:AutoConsumer] Failed to update state for crashed task ${taskId}: ${String(dbErr)}`);
+            }
+            throw runErr;
+        }
+        if (runResult.status === 'succeeded') {
+            const commitResult = await orchestrator.commitNextTaskProposal(taskId);
+            SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_SUCCESS', JSON.stringify({
+                taskId,
+                status: runResult.status,
+                successorDecision: commitResult.decision,
+            }));
+            logger.info(`[PD:AutoConsumer] Task ${taskId} succeeded. Successor: ${commitResult.decision}`);
+        }
+        else {
+            const errorCategory = runResult.errorCategory;
+            const failureReason = runResult.failureReason;
+            const nextAction = getNextActionForError(errorCategory);
+            SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_TASK_FAILED', JSON.stringify({
+                taskId,
+                status: runResult.status,
+                errorCategory,
+                failureReason,
+                nextAction,
+            }));
+            logger.warn(`[PD:AutoConsumer] Task ${taskId} status: ${runResult.status}. Category: ${errorCategory}. Reason: ${failureReason}. Next Action: ${nextAction}`);
+        }
+    }
+    catch (err) {
+        SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_ERROR', String(err));
+        logger.error(`[PD:AutoConsumer] Cycle error: ${String(err)}`);
+    }
+    finally {
+        if (handle) {
+            await handle.close().catch(() => { });
+        }
+    }
+}
+export const InternalizationAutoConsumerService = {
+    id: 'principles-internalization-auto-consumer',
+    start(ctx) {
+        const maybeWorkspaceDir = ctx?.workspaceDir;
+        const logger = ctx?.logger || console;
+        if (!maybeWorkspaceDir) {
+            logger.warn('[PD:AutoConsumer] No workspace directory, not starting.');
+            return;
+        }
+        const workspaceDir = maybeWorkspaceDir;
+        const state = getWorkspaceState(workspaceDir);
+        if (!state.stopped && state.timeoutId !== null) {
+            logger.info(`[PD:AutoConsumer] Already started for workspace: ${workspaceDir}`);
+            return;
+        }
+        const flag = loadFeatureFlagFromConfig(workspaceDir, INTERNALIZATION_AUTO_CONSUMER_FLAG_ID, {
+            info: (msg) => logger.info(msg),
+            warn: (msg) => logger.warn(msg),
+        });
+        if (!flag.enabled) {
+            const disabledInfo = JSON.stringify({
+                reason: 'internalization_auto_consumer_disabled',
+                nextAction: formatRunOnceCommand(workspaceDir),
+                flagSource: flag.source,
+            });
+            SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_DISABLED', disabledInfo);
+            logger.info(`[PD:AutoConsumer] NOT started for workspace: ${workspaceDir}. Disabled (source: ${flag.source}).`);
+            return;
+        }
+        state.stopped = false;
+        const interval = INTERNALIZATION_AUTO_CONSUMER_INTERVAL_MS;
+        function scheduleNext() {
+            if (state.stopped)
+                return;
+            state.timeoutId = setTimeout(runCycle, interval);
+            state.timeoutId?.unref();
+        }
+        async function runCycle() {
+            if (state.stopped)
+                return;
+            await runConsumerCycle(workspaceDir, logger);
+            scheduleNext();
+        }
+        state.timeoutId = setTimeout(() => {
+            void runCycle().catch((err) => {
+                logger.error(`[PD:AutoConsumer] Startup cycle failed: ${String(err)}`);
+                if (state.stopped)
+                    return;
+                state.timeoutId = setTimeout(runCycle, interval);
+                state.timeoutId?.unref();
+            });
+        }, INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS);
+        state.timeoutId?.unref();
+        SystemLogger.log(workspaceDir, 'INTERNALIZATION_CONSUMER_STARTED', JSON.stringify({
+            intervalMs: interval,
+            initialDelayMs: INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS,
+        }));
+        logger.info(`[PD:AutoConsumer] Started for workspace: ${workspaceDir} (interval: ${interval}ms, initial delay: ${INTERNALIZATION_AUTO_CONSUMER_INITIAL_DELAY_MS}ms)`);
+    },
+    stop(ctx) {
+        const workspaceDir = ctx?.workspaceDir;
+        if (workspaceDir) {
+            const state = workspaceStates.get(workspaceDir);
+            if (state) {
+                state.stopped = true;
+                if (state.timeoutId)
+                    clearTimeout(state.timeoutId);
+                state.timeoutId = null;
+            }
+            workspaceStates.delete(workspaceDir);
+        }
+        else {
+            for (const [, state] of workspaceStates) {
+                state.stopped = true;
+                if (state.timeoutId)
+                    clearTimeout(state.timeoutId);
+                state.timeoutId = null;
+            }
+            workspaceStates.clear();
+        }
+    },
+};

package/plugin/dist/types/event-types.d.ts

@@ -1,2 +1,2 @@
-export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, ToolCallStats, ErrorStats, PainStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
+export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, PainStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
 export { createEmptyDailyStats, } from '@principles/core/runtime-v2';

package/plugin/dist/utils/io.js

@@ -65,15 +65,36 @@ export function normalizePath(filePath, projectDir) {
             normalizedFilePath = `/mnt/${filePath.charAt(0).toLowerCase()}${filePath.slice(2).replace(/\\/g, '/')}`;
         }
     }
+    // POSIX absolute paths (e.g., /etc/passwd) are NOT recognized as absolute
+    // by path.isAbsolute() on Windows. When both the project dir and the file
+    // path are POSIX paths, use path.posix for relative computation.
+    const isPosixAbsolute = normalizedFilePath.startsWith('/') && !fileIsWin;
+    const projectIsPosix = !projectIsWin;
     let rel;
     if (projectIsWin) {
         const projectAbs = path.resolve(projectDir);
-        const fileAbs = path.isAbsolute(normalizedFilePath) ? normalizedFilePath : path.join(projectAbs, normalizedFilePath);
-        rel = path.relative(projectAbs, fileAbs);
+        if (isPosixAbsolute) {
+            // POSIX absolute path on Windows project: cannot resolve relative to project,
+            // return as-is (path is outside the project directory).
+            rel = normalizedFilePath;
+        }
+        else {
+            const fileAbs = path.isAbsolute(normalizedFilePath)
+                ? normalizedFilePath
+                : path.join(projectAbs, normalizedFilePath);
+            rel = path.relative(projectAbs, fileAbs);
+        }
+    }
+    else if (projectIsPosix && isPosixAbsolute) {
+        // Both project and file are POSIX → use path.posix
+        const projectPosix = projectDir.replace(/\\/g, '/');
+        rel = path.posix.relative(projectPosix, normalizedFilePath);
     }
     else {
         const projectPosix = projectDir.replace(/\\/g, '/');
-        const filePosix = path.isAbsolute(normalizedFilePath) ? normalizedFilePath : path.posix.join(projectPosix, normalizedFilePath.replace(/\\/g, '/'));
+        const filePosix = path.isAbsolute(normalizedFilePath)
+            ? normalizedFilePath
+            : path.posix.join(projectPosix, normalizedFilePath.replace(/\\/g, '/'));
         rel = path.posix.relative(projectPosix, filePosix);
     }
     rel = rel.replace(/\\/g, '/');

package/plugin/package.json

@@ -34,7 +34,7 @@
     "build:bundle": "node esbuild.config.js",
     "build:production": "node esbuild.config.js --production && node scripts/verify-build.mjs",
     "test": "vitest run",
-    "test:unit": "vitest run tests/core tests/service tests/hooks tests/commands tests/utils tests/scripts --exclude tests/commands/evolver.test.ts",
+    "test:unit": "vitest run --config vitest.unit.config.ts tests/core tests/service tests/hooks tests/commands tests/utils tests/scripts --exclude tests/commands/evolver.test.ts",
     "test:integration": "vitest run tests/integration/",
     "test:coverage": "vitest run --coverage",
     "test:all": "vitest run",
@@ -50,13 +50,14 @@
     "@types/micromatch": "^4.0.10",
     "@types/node": "^25.6.2",
     "@types/ws": "^8.5.13",
-    "@typescript-eslint/eslint-plugin": "^8.58.2",
+    "@typescript-eslint/eslint-plugin": "^8.61.0",
     "@typescript-eslint/parser": "^8.58.0",
     "@vitest/coverage-v8": "^4.1.8",
     "esbuild": "^0.28.0",
-    "eslint": "^10.4.1",
+    "eslint": "^10.5.0",
     "jsdom": "^29.1.1",
     "typescript": "^6.0.3",
+    "vite": "^8.0.16",
     "vitest": "^4.1.8",
     "ws": "^8.18.0"
   },

package/plugin/scripts/sync-plugin.mjs

@@ -923,6 +923,48 @@ function installTargetDependencies() {
     }
 }
 
+/**
+ * Verify injected workspace packages have their transitive dependencies installed.
+ * npm install --omit=dev in the target doesn't resolve deps of manually-copied packages,
+ * so transitive deps like @earendil-works/pi-agent-core may be missing after production install.
+ */
+function verifyInjectedWorkspaceDeps() {
+    const corePkgDir = join(INSTALL_DIR, 'node_modules', '@principles', 'core');
+    if (!existsSync(corePkgDir)) return;
+
+    const corePkgPath = join(corePkgDir, 'package.json');
+    if (!existsSync(corePkgPath)) return;
+
+    let corePkg;
+    try {
+        corePkg = JSON.parse(readFileSync(corePkgPath, 'utf-8'));
+    } catch (error) {
+        console.error(`  ❌ Failed to parse @principles/core/package.json: ${error.message}`);
+        process.exit(1);
+    }
+
+    const deps = corePkg.dependencies || {};
+    const missing = [];
+    for (const [dep, version] of Object.entries(deps)) {
+        if (!existsSync(join(INSTALL_DIR, 'node_modules', dep))) {
+            missing.push(`${dep}@${version}`);
+        }
+    }
+
+    if (missing.length === 0) return;
+
+    console.log(`  ⚠️  ${missing.length} transitive dependenc${missing.length === 1 ? 'y' : 'ies'} of @principles/core missing, installing...`);
+    try {
+        execSync(`npm install ${missing.join(' ')} --no-audit --no-fund --prefer-offline`, {
+            cwd: INSTALL_DIR,
+            stdio: 'pipe'
+        });
+        console.log('  ✅ Transitive dependencies installed');
+    } catch (error) {
+        console.warn(`  ⚠️  Failed to install transitive dependencies: ${error.message}`);
+    }
+}
+
 /**
  * Clean stale backups.
  */
@@ -1269,6 +1311,7 @@ function main() {
 
     injectLocalWorkspacePackages();
     installTargetDependencies();
+    verifyInjectedWorkspaceDeps();
     verifyPdCliShim();
 
     console.log('\n🔍 Verifying installed plugin can load native dependencies...');

package/plugin/templates/langs/en/principles/THINKING_OS.md

@@ -62,4 +62,16 @@ LLMs are highly sensitive to XML tags; this structure is designed to boost instr
     <must>Maintain extreme digital cleanliness. The project root is SACRED. Use strict `kebab-case` for all naming. Clean up all test scripts and debug artifacts after the task.</must>
     <forbidden>Creating arbitrary temporary files (e.g., `test.txt`, `temp.md`, `debug.log`) in the project root directory.</forbidden>
   </directive>
+
+  <directive id="T-09" name="DIVIDE_AND_CONQUER">
+    <trigger>When facing a complex task, multi-step change, or an operation that can be decomposed.</trigger>
+    <must>Break the task into smaller, manageable phases before execution. Execute one phase at a time and verify each phase's result before proceeding.</must>
+    <forbidden>Attempting to execute a large, complex change in a single step, or proceeding without a decomposition plan.</forbidden>
+  </directive>
+
+  <directive id="T-10" name="MEMORY_EXTERNALIZATION">
+    <trigger>When reaching a significant conclusion, making a decision, or planning next steps across sessions.</trigger>
+    <must>Write intermediate conclusions, decisions, and plans to persistent files (e.g., plan.md, scratchpad) so they survive context compression and session boundaries.</must>
+    <forbidden>Relying solely on conversation context to retain important state that will be lost when the context window shifts.</forbidden>
+  </directive>
 </thinking_os_core_directives>

package/plugin/templates/langs/en/skills/pd-runtime-v2/SKILL.md

@@ -14,7 +14,7 @@ Automatic:
 - Tool failures first accumulate GFI/friction.
 - Only high-value episodes enter Runtime V2: high GFI, repeated same failure, severe semantic pain, LLM paralysis, or explicit manual pain.
 - Approved `pain_detected` events enter `PainSignalBridge`.
-- The bridge runs `DiagnosticianRunner`, commits candidates, and intakes them into the ledger.
+- The bridge runs `SplitDiagnosticianRunner`, commits candidates, and intakes them into the ledger.
 
 Manual:
 ```bash

package/plugin/templates/langs/zh/principles/THINKING_OS.md

@@ -62,4 +62,16 @@
     <must>保持极致的数字洁癖。项目根目录是神圣的。所有命名必须严格使用 `kebab-case`。任务结束后清理所有的测试脚本和 Debug 遗留物。</must>
     <forbidden>在项目根目录下随意创建临时文件（如 `test.txt`、`temp.md`、`debug.log`）。</forbidden>
   </directive>
+
+  <directive id="T-09" name="DIVIDE_AND_CONQUER">
+    <trigger>当面对复杂任务、多步骤变更或可分解的操作时。</trigger>
+    <must>在执行前将任务拆分为更小的、可管理的阶段。逐阶段执行，并在进入下一阶段前验证当前阶段的结果。</must>
+    <forbidden>试图在单一步骤中执行大型复杂变更，或在没有分解计划的情况下直接推进。</forbidden>
+  </directive>
+
+  <directive id="T-10" name="MEMORY_EXTERNALIZATION">
+    <trigger>当得出重要结论、做出决策或规划跨会话的后续步骤时。</trigger>
+    <must>将中间结论、决策和计划写入持久化文件（如 plan.md、scratchpad），使其在上下文压缩和会话边界后仍然可用。</must>
+    <forbidden>仅依赖对话上下文来保持重要状态，这些状态在上下文窗口切换时将丢失。</forbidden>
+  </directive>
 </thinking_os_core_directives>

package/plugin/templates/langs/zh/skills/pd-runtime-v2/SKILL.md

@@ -14,7 +14,7 @@ disable-model-invocation: false
 - 工具失败先累计 GFI/摩擦。
 - 只有高价值 episode 才进入 Runtime V2：高 GFI、重复同类失败、严重语义痛苦、LLM paralysis，或明确手动 pain。
 - 通过门控的 `pain_detected` 进入 `PainSignalBridge`。
-- Bridge 调用 `DiagnosticianRunner`，提交 candidate，并 intake 到 ledger。
+- Bridge 调用 `SplitDiagnosticianRunner`，提交 candidate，并 intake 到 ledger。
 
 手动入口：
 ```bash

package/templates/langs/en/principles/THINKING_OS.md

@@ -62,4 +62,16 @@ LLMs are highly sensitive to XML tags; this structure is designed to boost instr
     <must>Maintain extreme digital cleanliness. The project root is SACRED. Use strict `kebab-case` for all naming. Clean up all test scripts and debug artifacts after the task.</must>
     <forbidden>Creating arbitrary temporary files (e.g., `test.txt`, `temp.md`, `debug.log`) in the project root directory.</forbidden>
   </directive>
+
+  <directive id="T-09" name="DIVIDE_AND_CONQUER">
+    <trigger>When facing a complex task, multi-step change, or an operation that can be decomposed.</trigger>
+    <must>Break the task into smaller, manageable phases before execution. Execute one phase at a time and verify each phase's result before proceeding.</must>
+    <forbidden>Attempting to execute a large, complex change in a single step, or proceeding without a decomposition plan.</forbidden>
+  </directive>
+
+  <directive id="T-10" name="MEMORY_EXTERNALIZATION">
+    <trigger>When reaching a significant conclusion, making a decision, or planning next steps across sessions.</trigger>
+    <must>Write intermediate conclusions, decisions, and plans to persistent files (e.g., plan.md, scratchpad) so they survive context compression and session boundaries.</must>
+    <forbidden>Relying solely on conversation context to retain important state that will be lost when the context window shifts.</forbidden>
+  </directive>
 </thinking_os_core_directives>

package/templates/langs/zh/principles/THINKING_OS.md

@@ -62,4 +62,16 @@
     <must>保持极致的数字洁癖。项目根目录是神圣的。所有命名必须严格使用 `kebab-case`。任务结束后清理所有的测试脚本和 Debug 遗留物。</must>
     <forbidden>在项目根目录下随意创建临时文件（如 `test.txt`、`temp.md`、`debug.log`）。</forbidden>
   </directive>
+
+  <directive id="T-09" name="DIVIDE_AND_CONQUER">
+    <trigger>当面对复杂任务、多步骤变更或可分解的操作时。</trigger>
+    <must>在执行前将任务拆分为更小的、可管理的阶段。逐阶段执行，并在进入下一阶段前验证当前阶段的结果。</must>
+    <forbidden>试图在单一步骤中执行大型复杂变更，或在没有分解计划的情况下直接推进。</forbidden>
+  </directive>
+
+  <directive id="T-10" name="MEMORY_EXTERNALIZATION">
+    <trigger>当得出重要结论、做出决策或规划跨会话的后续步骤时。</trigger>
+    <must>将中间结论、决策和计划写入持久化文件（如 plan.md、scratchpad），使其在上下文压缩和会话边界后仍然可用。</must>
+    <forbidden>仅依赖对话上下文来保持重要状态，这些状态在上下文窗口切换时将丢失。</forbidden>
+  </directive>
 </thinking_os_core_directives>

package/console/dist/server/routes/state.d.ts

@@ -1,11 +0,0 @@
-/**
- * State API — exposes stalled/dirty workspace tasks for operator inspection.
- *
- * GET /api/v1/state
- *   Returns all tasks in needs_human_review status with workspace and error info.
- *
- * GET /api/v1/state/:taskId
- *   Returns detailed state for a specific task including dirty files.
- */
-import type { IncomingMessage, ServerResponse } from 'node:http';
-export declare function handleStateRoute(req: IncomingMessage, res: ServerResponse, workspaceDir: string, subPath: string): Promise<void>;

package/console/dist/server/routes/state.js

@@ -1,97 +0,0 @@
-import { sendSuccess, sendError, sendNotFound } from '../utils/response.js';
-function extractDirtyFiles(diagnosticJson) {
-    if (!diagnosticJson)
-        return [];
-    try {
-        const parsed = JSON.parse(diagnosticJson);
-        return parsed.dirtyFiles ?? [];
-    }
-    catch {
-        return [];
-    }
-}
-function extractWorkspaceDir(diagnosticJson) {
-    if (!diagnosticJson)
-        return null;
-    try {
-        const parsed = JSON.parse(diagnosticJson);
-        return parsed.workspaceDir ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-async function getHumanReviewTasks(stateManager) {
-    const tasks = await stateManager.listTasks({ status: 'needs_human_review' });
-    return tasks.map((task) => ({
-        taskId: task.taskId,
-        taskKind: task.taskKind,
-        workspaceDir: extractWorkspaceDir(task.diagnosticJson),
-        dirtyFiles: extractDirtyFiles(task.diagnosticJson),
-        lastError: task.lastError ?? null,
-        attemptCount: task.attemptCount,
-        updatedAt: task.updatedAt,
-        diagnosticJson: task.diagnosticJson ? JSON.parse(task.diagnosticJson) : null,
-    }));
-}
-async function getTaskState(stateManager, taskId) {
-    const task = await stateManager.getTask(taskId);
-    if (!task)
-        return null;
-    return {
-        taskId: task.taskId,
-        taskKind: task.taskKind,
-        workspaceDir: extractWorkspaceDir(task.diagnosticJson),
-        dirtyFiles: extractDirtyFiles(task.diagnosticJson),
-        lastError: task.lastError ?? null,
-        attemptCount: task.attemptCount,
-        updatedAt: task.updatedAt,
-        diagnosticJson: task.diagnosticJson ? JSON.parse(task.diagnosticJson) : null,
-    };
-}
-/* eslint-disable @typescript-eslint/max-params */
-export async function handleStateRoute(req, res, workspaceDir, subPath) {
-    // Lazy import to avoid circular dependency issues
-    const { RuntimeStateManager } = await import('@principles/core/runtime-v2');
-    if (req.method !== 'GET') {
-        sendError(res, 405, 'method_not_allowed', 'Only GET is allowed for this route');
-        return;
-    }
-    const stateManager = new RuntimeStateManager({ workspaceDir });
-    await stateManager.initialize();
-    try {
-        // GET /api/v1/state
-        if (subPath === '' || subPath === '/' || subPath === '/tasks') {
-            const tasks = await getHumanReviewTasks(stateManager);
-            sendSuccess(res, {
-                status: 'ok',
-                tasks,
-                count: tasks.length,
-            });
-            return;
-        }
-        // GET /api/v1/state/:taskId
-        const parts = subPath.split('/').filter(Boolean);
-        if (parts.length === 1 && parts[0]) {
-            const [taskId] = parts;
-            const taskState = await getTaskState(stateManager, taskId);
-            if (!taskState) {
-                sendNotFound(res, `Task ${taskId} not found`);
-                return;
-            }
-            sendSuccess(res, {
-                status: 'ok',
-                task: taskState,
-            });
-            return;
-        }
-        sendNotFound(res, `Route /api/v1/state${subPath} not found`);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        sendError(res, 500, 'state_error', message);
-    }
-    finally {
-        await stateManager.close();
-    }
-}

package/console/dist/ui/components/UpdateBanner.d.ts

@@ -1 +0,0 @@
-export declare function UpdateBanner(): import("react/jsx-runtime").JSX.Element | null;