principles-disciple 1.126.0 → 1.128.0

package/dist/commands/promote-impl.js

@@ -0,0 +1,194 @@
+/**
+ * Promote Implementation Command — CLI `/pd-promote-impl`
+ * ========================================================
+ *
+ * PURPOSE: Manually promote a candidate implementation to active status
+ * after replay evaluation review.
+ *
+ * FLOW:
+ *   1. List candidates with replay reports
+ *   2. Show replay report summary for selected candidate
+ *   3. Ask for confirmation
+ *   4. On confirm: transition candidate->active, demote previous active->disabled
+ *
+ * VALIDATION:
+ *   - Candidate must have at least one replay report with 'pass' decision
+ *   - Only candidate -> active is valid for promotion
+ *   - NOTE (PRI-230): The legacy replay generation path has been retired.
+ *     This command is temporarily unavailable for implementations without
+ *     pre-existing replay reports until a Runtime V2 replay entry is wired.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { ReplayEngine, formatReplayReport } from '../core/replay-engine.js';
+import { refreshPrincipleLifecycle } from '../core/principle-internalization/lifecycle-refresh.js';
+import { findActiveImplementation, loadLedger, transitionImplementationState, updateImplementation, } from '../core/principle-tree-ledger.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { normalizeCommandArgs } from '../utils/io.js';
+import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
+import { withLock } from '../utils/file-lock.js';
+import { atomicWriteFileSync } from '../utils/io.js';
+function getAllImplementations(stateDir) {
+    const ledger = loadLedger(stateDir);
+    return Object.values(ledger.tree.implementations);
+}
+/**
+ * Type predicate: true if impl has lifecycleState of 'candidate' or 'disabled'.
+ * The ledger adds lifecycleState at runtime beyond what's in the manifest interface.
+ */
+function isCandidateOrDisabled(impl) {
+    return impl.lifecycleState === 'candidate' || impl.lifecycleState === 'disabled';
+}
+function _handleListCandidates(stateDir, isZh) {
+    const engine = new ReplayEngine('', stateDir);
+    const allImpls = getAllImplementations(stateDir);
+    const candidates = allImpls.filter(isCandidateOrDisabled);
+    if (candidates.length === 0) {
+        return {
+            text: isZh
+                ? '\nℹ️ 未找到候选实现。\n\n用法: /pd-promote-impl list'
+                : '\nℹ️ No candidate implementations found.\n\nUsage: /pd-promote-impl list',
+        };
+    }
+    let output = isZh ? '\n📋 候选实现列表\n' : '\n📋 Candidate Implementations\n';
+    output += `${'='.repeat(50)}\n`;
+    for (const impl of candidates) {
+        const hasPass = engine.hasPassingReport(impl.id);
+        const passBadge = hasPass
+            ? isZh ? '✅ 有通过报告' : '✅ Has pass report'
+            : isZh ? '❌ 无通过报告' : '❌ No pass report';
+        output += `  ${impl.id}\n`;
+        output += `    Rule: ${impl.ruleId} | Version: ${impl.version}\n`;
+        output += `    Replay: ${passBadge}\n\n`;
+    }
+    return { text: output };
+}
+function _handleShowReport(stateDir, implId, isZh) {
+    const engine = new ReplayEngine('', stateDir);
+    const report = engine.getLatestReport(implId);
+    if (!report) {
+        return {
+            text: isZh
+                ? `❌ 实现 ${implId} 没有回放报告。`
+                : `❌ No replay report found for implementation ${implId}.`,
+        };
+    }
+    return { text: formatReplayReport(report) };
+}
+function _handlePromoteImpl(options) {
+    const { workspaceDir, stateDir, implId, isZh } = options;
+    const engine = new ReplayEngine('', stateDir);
+    const allImpls = getAllImplementations(stateDir);
+    const candidate = allImpls.find((i) => i.id === implId);
+    if (!candidate) {
+        return {
+            text: isZh
+                ? `❌ 未找到实现: ${implId}`
+                : `❌ Implementation not found: ${implId}`,
+        };
+    }
+    const currentState = candidate.lifecycleState || 'candidate';
+    if (currentState !== 'candidate' && currentState !== 'disabled') {
+        return {
+            text: isZh
+                ? `❌ 只能晋升 candidate 或 disabled 状态的实现。当前: ${currentState}`
+                : `❌ Can only promote 'candidate' or 'disabled' implementations. Current: ${currentState}`,
+        };
+    }
+    if (!engine.hasPassingReport(implId)) {
+        return {
+            text: isZh
+                ? `❌ 实现 ${implId} 没有通过的回放报告，晋升被拒绝。\n\nLegacy replay 生成路径已在 PRI-230 退役，当前无可用的 replay 证据生成入口。该命令暂不可用于没有既有 replay 报告的实现。`
+                : `❌ Implementation ${implId} has no passing replay report. Promotion rejected.\n\nThe legacy replay generation path was retired in PRI-230; no replay evidence generation entry is currently available. This command is temporarily unavailable for implementations without pre-existing replay reports.`,
+        };
+    }
+    const report = engine.getLatestReport(implId);
+    let output = '';
+    if (report) {
+        output = `${formatReplayReport(report)}\n`;
+    }
+    if (currentState === 'disabled') {
+        transitionImplementationState(stateDir, implId, 'active');
+        updateImplementation(stateDir, implId, {
+            disabledAt: undefined,
+            disabledBy: undefined,
+            disabledReason: undefined,
+        });
+        try {
+            refreshPrincipleLifecycle(workspaceDir, stateDir);
+        }
+        catch (err) {
+            console.warn('[promote-impl] Lifecycle refresh failed (re-enable):', err instanceof Error ? err.stack : err);
+        }
+        output += isZh
+            ? `\n✅ 实现已重新启用: ${implId}\n   状态: disabled -> active`
+            : `\n✅ Implementation re-enabled: ${implId}\n   State: disabled -> active`;
+        return { text: output };
+    }
+    const activeForRule = findActiveImplementation(stateDir, candidate.ruleId);
+    if (activeForRule) {
+        updateImplementation(stateDir, implId, {
+            previousActive: activeForRule.id,
+        });
+    }
+    transitionImplementationState(stateDir, implId, 'active');
+    if (activeForRule) {
+        transitionImplementationState(stateDir, activeForRule.id, 'disabled');
+        output += isZh
+            ? `\n上一个活跃实现已禁用: ${activeForRule.id}\n   状态: active -> disabled`
+            : `\nPrevious active implementation disabled: ${activeForRule.id}\n   State: active -> disabled`;
+    }
+    const eventsDir = path.join(stateDir, 'principles', 'implementations', implId, 'events');
+    if (!fs.existsSync(eventsDir)) {
+        fs.mkdirSync(eventsDir, { recursive: true });
+    }
+    const eventPath = path.join(eventsDir, 'promotion.json');
+    const promotionEvent = {
+        eventType: 'promotion',
+        implementationId: implId,
+        ruleId: candidate.ruleId,
+        fromState: 'candidate',
+        toState: 'active',
+        previousActive: activeForRule?.id ?? null,
+        replayReportId: report
+            ? report.generatedAt.replace(/[:.]/g, '-')
+            : null,
+        promotedAt: new Date().toISOString(),
+    };
+    withLock(eventPath, () => {
+        atomicWriteFileSync(eventPath, JSON.stringify(promotionEvent, null, 2));
+    });
+    try {
+        refreshPrincipleLifecycle(workspaceDir, stateDir);
+    }
+    catch (err) {
+        console.warn('[promote-impl] Lifecycle refresh failed (promotion):', err instanceof Error ? err.stack : err);
+    }
+    output += isZh
+        ? `\n\n✅ 实现已晋升: ${implId}\n   状态: candidate -> active`
+        : `\n\n✅ Implementation promoted: ${implId}\n   State: candidate -> active`;
+    return { text: output };
+}
+export function handlePromoteImplCommand(ctx) {
+    const workspaceDir = resolvePluginCommandWorkspaceDir(ctx, 'promote-impl');
+    const { stateDir } = WorkspaceContext.fromHookContext({ ...ctx, workspaceDir });
+    const lang = ctx.config?.language || 'en';
+    const isZh = lang === 'zh';
+    const args = normalizeCommandArgs(ctx.args).trim().split(/\s+/);
+    const subcommand = args[0] || '';
+    const implId = args[1] || '';
+    if (subcommand === 'list' || subcommand === '') {
+        return _handleListCandidates(stateDir, isZh);
+    }
+    if (subcommand === 'show') {
+        if (!implId) {
+            return {
+                text: isZh
+                    ? '请指定要查看的实现ID: /pd-promote-impl show <implId>'
+                    : 'Please specify an implementation ID: /pd-promote-impl show <implId>',
+            };
+        }
+        return _handleShowReport(stateDir, implId, isZh);
+    }
+    return _handlePromoteImpl({ workspaceDir, stateDir, implId: subcommand, isZh });
+}

package/dist/commands/rollback-impl.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Rollback Implementation Command — CLI `/pd-rollback-impl`
+ * ==========================================================
+ *
+ * PURPOSE: Revert the current active implementation and restore the previous one.
+ *
+ * FLOW:
+ *   1. List active implementations
+ *   2. On confirm: current -> disabled, previous -> active
+ *
+ * SAFETY:
+ *   - If no previous active: current -> disabled (degrades to hard-boundary gates)
+ *   - Rollback records persisted with full audit trail
+ */
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+/**
+ * Handle the /pd-rollback-impl command.
+ *
+ * Usage:
+ *   /pd-rollback-impl list                          - List active implementations
+ *   /pd-rollback-impl <implId>                      - Rollback current active
+ *   /pd-rollback-impl <implId> --reason "<reason>"  - Rollback with reason
+ */
+export declare function handleRollbackImplCommand(ctx: PluginCommandContext): PluginCommandResult;
+/**
+ * Handle natural language rollback request.
+ * Detects phrases like "回滚这个规则实现", "rollback this implementation".
+ */
+export declare function handleNaturalLanguageRollbackImpl(workspaceDir: string, sessionId: string | undefined, reason: string): {
+    success: boolean;
+    message: string;
+};

package/dist/commands/rollback-impl.js

@@ -0,0 +1,180 @@
+/**
+ * Rollback Implementation Command — CLI `/pd-rollback-impl`
+ * ==========================================================
+ *
+ * PURPOSE: Revert the current active implementation and restore the previous one.
+ *
+ * FLOW:
+ *   1. List active implementations
+ *   2. On confirm: current -> disabled, previous -> active
+ *
+ * SAFETY:
+ *   - If no previous active: current -> disabled (degrades to hard-boundary gates)
+ *   - Rollback records persisted with full audit trail
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { withLock } from '../utils/file-lock.js';
+import { atomicWriteFileSync } from '../utils/io.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { refreshPrincipleLifecycle } from '../core/principle-internalization/lifecycle-refresh.js';
+import { loadLedger, transitionImplementationState, } from '../core/principle-tree-ledger.js';
+import { normalizeCommandArgs } from '../utils/io.js';
+import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
+/**
+ * Get all implementations from the ledger.
+ */
+function getAllImplementations(stateDir) {
+    const ledger = loadLedger(stateDir);
+    return Object.values(ledger.tree.implementations);
+}
+/**
+ * Handle the /pd-rollback-impl command.
+ *
+ * Usage:
+ *   /pd-rollback-impl list                          - List active implementations
+ *   /pd-rollback-impl <implId>                      - Rollback current active
+ *   /pd-rollback-impl <implId> --reason "<reason>"  - Rollback with reason
+ */
+export function handleRollbackImplCommand(ctx) {
+    const workspaceDir = resolvePluginCommandWorkspaceDir(ctx, 'rollback-impl');
+    const { stateDir } = WorkspaceContext.fromHookContext({ ...ctx, workspaceDir });
+    const lang = ctx.config?.language || 'en';
+    const isZh = lang === 'zh';
+    const args = normalizeCommandArgs(ctx.args).trim();
+    // Parse args
+    const subcommand = args.split(/\s+/)[0] || '';
+    const implId = subcommand === 'list' ? '' : subcommand;
+    const reasonMatch = (/--reason\s+"([^"]+)"/.exec(args)) || (/--reason\s+(\S+)/.exec(args));
+    const reason = reasonMatch ? reasonMatch[1] : null;
+    // List active
+    if (subcommand === 'list' || subcommand === '') {
+        return _handleListActiveRollback(stateDir, isZh);
+    }
+    return _handleRollbackImpl(workspaceDir, stateDir, implId, reason, isZh, ctx.sessionId);
+}
+function _handleListActiveRollback(stateDir, isZh) {
+    const allImpls = getAllImplementations(stateDir);
+    const activeImpls = allImpls.filter((impl) => impl.lifecycleState === 'active');
+    if (activeImpls.length === 0) {
+        return {
+            text: isZh
+                ? '\n\u2139\ufe0f \u6ca1\u6709\u6d3b\u8dc3\u5b9e\u73b0\u53ef\u56de\u6eda\u3002'
+                : '\n\u2139\ufe0f No active implementations to rollback.',
+        };
+    }
+    let output = isZh ? '\n\ud83d\udccb \u53ef\u56de\u6eda\u6d3b\u8dc3\u5b9e\u73b0\n' : '\n\ud83d\udccb Active Implementations Available for Rollback\n';
+    output += `${'='.repeat(50)}\n`;
+    for (const impl of activeImpls) {
+        const hasPrevious = impl.previousActive ? '\u2705' : '\u26a0\ufe0f \u65e0\u524d\u4e00\u4e2a';
+        output += `  ${impl.id}\n`;
+        output += `    Rule: ${impl.ruleId} | Version: ${impl.version}\n`;
+        output += `    Has previous: ${hasPrevious}\n`;
+        if (impl.previousActive) {
+            output += `    Previous: ${impl.previousActive}\n`;
+        }
+        output += '\n';
+    }
+    output += isZh
+        ? '\u7528\u6cd5: /pd-rollback-impl <implId> --reason "\u539f\u56e0"'
+        : 'Usage: /pd-rollback-impl <implId> --reason "reason"';
+    return { text: output };
+}
+function _handleRollbackImpl(workspaceDir, stateDir, implId, reason, isZh, sessionId) {
+    const allImpls = getAllImplementations(stateDir);
+    const currentActive = allImpls.find((i) => i.id === implId);
+    if (!currentActive) {
+        return {
+            text: isZh
+                ? `\u274c \u672a\u627e\u5230\u5b9e\u73b0: ${implId}`
+                : `\u274c Implementation not found: ${implId}`,
+        };
+    }
+    const currentState = currentActive.lifecycleState;
+    if (currentState !== 'active') {
+        return {
+            text: isZh
+                ? `\u274c \u5b9e\u73b0 ${implId} \u5f53\u524d\u72b6\u6001: ${currentState}\n\u53ea\u80fd\u56de\u6eda\u6d3b\u8dc3\u5b9e\u73b0\u3002`
+                : `\u274c Implementation ${implId} is in state: ${currentState}\nCan only rollback active implementations.`,
+        };
+    }
+    const previousActiveId = currentActive.previousActive;
+    const reasonText = reason || (isZh ? '\u7528\u6237\u624b\u52a8\u56de\u6eda' : 'User manual rollback');
+    // Step 1: Current active -> disabled
+    transitionImplementationState(stateDir, implId, 'disabled');
+    let restoredMessage;
+    if (previousActiveId && allImpls.some((i) => i.id === previousActiveId)) {
+        // Step 2: Restore previous active -> active
+        transitionImplementationState(stateDir, previousActiveId, 'active');
+        restoredMessage = isZh
+            ? `\n   \u5df2\u6062\u590d\u524d\u4e00\u4e2a\u6d3b\u8dc3\u5b9e\u73b0: ${previousActiveId}\n   \u72b6\u6001: disabled -> active`
+            : `\n   Restored previous active implementation: ${previousActiveId}\n   State: disabled -> active`;
+    }
+    else {
+        // No previous active — degrade to hard-boundary gates (per Phase 12 D-08)
+        restoredMessage = isZh
+            ? `\n   \u26a0\ufe0f \u6ca1\u6709\u524d\u4e00\u4e2a\u6d3b\u8dc3\u5b9e\u73b0\uff0c\u8be5\u89c4\u5219\u6ca1\u6709\u6d3b\u8dc3\u5b9e\u73b0\u3002`
+                + `\n   GFI\u3001Progressive Gate\u7b49\u786c\u56fa\u62b1\u95e8\u4ecd\u7136\u6b63\u5e38\u8fd0\u884c\u3002`
+            : `\n   \u26a0\ufe0f No previous active implementation. Rule has no active code implementation.`
+                + ` Existing hard-boundary gates (GFI, Progressive Gate) continue functioning normally.`;
+    }
+    // Store rollback record
+    const rollbackDir = path.join(stateDir, 'principles', 'implementations', implId, 'rollbacks');
+    if (!fs.existsSync(rollbackDir)) {
+        fs.mkdirSync(rollbackDir, { recursive: true });
+    }
+    const rollbackRecord = {
+        rolledBackBy: sessionId || 'manual',
+        rolledBackAt: new Date().toISOString(),
+        reason: reasonText,
+        previousImplementationId: previousActiveId || null,
+        restoredImplementationId: previousActiveId && allImpls.some((i) => i.id === previousActiveId)
+            ? previousActiveId
+            : null,
+        rolledBackImplId: implId,
+    };
+    const rollbackTimestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const rollbackPath = path.join(rollbackDir, `${rollbackTimestamp}.json`);
+    withLock(rollbackPath, () => {
+        atomicWriteFileSync(rollbackPath, JSON.stringify(rollbackRecord, null, 2));
+    });
+    try {
+        refreshPrincipleLifecycle(workspaceDir, stateDir);
+    }
+    catch (err) {
+        console.warn('[rollback-impl] Lifecycle refresh failed:', err instanceof Error ? err.stack : err);
+    }
+    let output = isZh
+        ? `\n\u2705 \u56de\u6eda\u5b8c\u6210: ${implId}\n   \u72b6\u6001: active -> disabled\n   \u539f\u56e0: ${reasonText}`
+        : `\n\u2705 Rollback complete: ${implId}\n   State: active -> disabled\n   Reason: ${reasonText}`;
+    output += restoredMessage;
+    return { text: output };
+}
+/**
+ * Handle natural language rollback request.
+ * Detects phrases like "回滚这个规则实现", "rollback this implementation".
+ */
+export function handleNaturalLanguageRollbackImpl(workspaceDir, sessionId, reason) {
+    const isZh = (/[\u4e00-\u9fff]/.exec(reason)) || false;
+    const { stateDir } = WorkspaceContext.fromHookContext({ workspaceDir });
+    if (!sessionId) {
+        return {
+            success: false,
+            message: isZh ? '\u65e0\u6cd5\u8bc6\u522b\u5f53\u524d\u4f1a\u8bdd' : 'Session not found',
+        };
+    }
+    // Natural language entry: get last active implementation
+    const allImpls = getAllImplementations(stateDir);
+    const lastActive = allImpls.find((i) => i.lifecycleState === 'active');
+    if (!lastActive) {
+        return {
+            success: false,
+            message: isZh ? '\u5f53\u524d\u6ca1\u6709\u6d3b\u8dc3\u5b9e\u73b0' : 'No active implementations',
+        };
+    }
+    // Would be called via the hook — return the impl ID for the hook to route
+    return {
+        success: true,
+        message: `${lastActive.id}|${reason}`,
+    };
+}

package/dist/commands/rollback.d.ts

@@ -0,0 +1,19 @@
+import { WorkspaceContext } from '../core/workspace-context.js';
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+/**
+ * Handles the /pd-rollback command
+ *
+ * Usage:
+ *   /pd-rollback <event-id>  - Rollback a specific empathy event by ID
+ *   /pd-rollback last        - Rollback the last empathy event in current session
+ */
+export declare function handleRollbackCommand(ctx: PluginCommandContext): PluginCommandResult;
+/**
+ * Handle natural language rollback request
+ * Called from prompt hook when user says things like "撤销刚才的惩罚"
+ */
+export declare function handleNaturalLanguageRollback(wctx: WorkspaceContext, sessionId: string | undefined, reason: string): {
+    success: boolean;
+    score: number;
+    message: string;
+};

package/{src/commands/rollback.ts → dist/commands/rollback.js}

@@ -1,34 +1,21 @@
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { resetFriction } from '../core/session-tracker.js';
-import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
 import { normalizeCommandArgs } from '../utils/io.js';
 import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
-
-/**
- * Extended context interface that includes sessionId injected by the plugin framework.
- * PluginCommandContext does not include sessionId in its type definition.
- */
-interface SessionAwareCommandContext extends PluginCommandContext {
-  sessionId: string;
-}
-
 /**
  * Handles the /pd-rollback command
- * 
+ *
  * Usage:
  *   /pd-rollback <event-id>  - Rollback a specific empathy event by ID
  *   /pd-rollback last        - Rollback the last empathy event in current session
  */
-export function handleRollbackCommand(ctx: PluginCommandContext): PluginCommandResult {
+export function handleRollbackCommand(ctx) {
     const workspaceDir = resolvePluginCommandWorkspaceDir(ctx, 'rollback');
-    
     const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
-    const lang = (ctx.config?.language as string) || 'en';
+    const lang = ctx.config?.language || 'en';
     const isZh = lang === 'zh';
-    const { sessionId } = ctx as SessionAwareCommandContext;
-
+    const { sessionId } = ctx;
     const args = normalizeCommandArgs(ctx.args).trim();
-
     if (!args) {
         return {
             text: isZh
@@ -44,7 +31,6 @@ Usage:
   /pd-rollback last        - Rollback the last event in current session`
         };
     }
-
     if (!sessionId) {
         return {
             text: isZh
@@ -52,12 +38,7 @@ Usage:
                 : `❌ Session ID not found. Use this command in a chat session.`
         };
     }
-
-     
-     
-    let eventId: string | null;
-     
-
+    let eventId;
     if (args === 'last') {
         // Find the last empathy event in current session
         eventId = wctx.eventLog.getLastEmpathyEventId(sessionId);
@@ -68,19 +49,13 @@ Usage:
                     : `❌ No empathy events found in current session to rollback.`
             };
         }
-    } else {
+    }
+    else {
         // Use the provided event ID
         eventId = args;
     }
-
     // Perform rollback
-    const rolledBackScore = wctx.eventLog.rollbackEmpathyEvent(
-        eventId,
-        sessionId,
-        isZh ? '用户手动回滚' : 'User manual rollback',
-        'user_command'
-    );
-
+    const rolledBackScore = wctx.eventLog.rollbackEmpathyEvent(eventId, sessionId, isZh ? '用户手动回滚' : 'User manual rollback', 'user_command');
     if (rolledBackScore === 0) {
         return {
             text: isZh
@@ -88,13 +63,11 @@ Usage:
                 : `❌ Failed to rollback event "${eventId}". Event may not exist or was deduped.`
         };
     }
-
     // Reduce the GFI by the rolled back score
     resetFriction(sessionId, workspaceDir, {
         source: 'user_empathy',
         amount: rolledBackScore,
     });
-
     return {
         text: isZh
             ? `✅ 已回滚情绪事件
@@ -109,18 +82,12 @@ Usage:
 💡 Hint: Session friction has been reset.`
     };
 }
-
 /**
  * Handle natural language rollback request
  * Called from prompt hook when user says things like "撤销刚才的惩罚"
  */
-export function handleNaturalLanguageRollback(
-    wctx: WorkspaceContext,
-    sessionId: string | undefined,
-    reason: string
-): { success: boolean; score: number; message: string } {
+export function handleNaturalLanguageRollback(wctx, sessionId, reason) {
     const isZh = wctx.config.get('language') === 'zh';
-
     if (!sessionId) {
         return {
             success: false,
@@ -128,7 +95,6 @@ export function handleNaturalLanguageRollback(
             message: isZh ? '无法识别当前会话' : 'Session not found'
         };
     }
-
     const eventId = wctx.eventLog.getLastEmpathyEventId(sessionId);
     if (!eventId) {
         return {
@@ -137,14 +103,7 @@ export function handleNaturalLanguageRollback(
             message: isZh ? '当前会话没有可回滚的情绪事件' : 'No empathy events to rollback'
         };
     }
-
-    const rolledBackScore = wctx.eventLog.rollbackEmpathyEvent(
-        eventId,
-        sessionId,
-        reason,
-        'natural_language'
-    );
-
+    const rolledBackScore = wctx.eventLog.rollbackEmpathyEvent(eventId, sessionId, reason, 'natural_language');
     if (rolledBackScore === 0) {
         return {
             success: false,
@@ -152,13 +111,11 @@ export function handleNaturalLanguageRollback(
             message: isZh ? '回滚失败，事件可能不存在' : 'Rollback failed, event may not exist'
         };
     }
-
     // Reduce only the empathy slice instead of wiping the whole session GFI.
     resetFriction(sessionId, wctx.workspaceDir, {
         source: 'user_empathy',
         amount: rolledBackScore,
     });
-
     return {
         success: true,
         score: rolledBackScore,

package/dist/commands/samples.d.ts

@@ -0,0 +1,2 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+export declare function handleSamplesCommand(ctx: PluginCommandContext): PluginCommandResult;

package/dist/commands/samples.js

@@ -0,0 +1,58 @@
+import { WorkspaceContext } from '../core/workspace-context.js';
+import { normalizeCommandArgs } from '../utils/io.js';
+import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
+function isZh(ctx) {
+    return String(ctx.config?.language || 'en').startsWith('zh');
+}
+export function handleSamplesCommand(ctx) {
+    const workspaceDir = resolvePluginCommandWorkspaceDir(ctx, 'samples');
+    const zh = isZh(ctx);
+    const args = normalizeCommandArgs(ctx.args).trim();
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    if (args.startsWith('review ')) {
+        const [, decision = '', sampleId = '', ...noteParts] = args.split(/\s+/);
+        if (decision !== 'approve' && decision !== 'reject') {
+            return {
+                text: zh
+                    ? '无效的审核动作。请使用 `review approve <sample-id> [note]` 或 `review reject <sample-id> [note]`。'
+                    : 'Invalid review action. Use `review approve <sample-id> [note]` or `review reject <sample-id> [note]`.',
+            };
+        }
+        if (!sampleId) {
+            return {
+                text: zh
+                    ? '缺少 sample-id。'
+                    : 'Missing sample-id.',
+            };
+        }
+        const normalizedDecision = decision === 'approve' ? 'approved' : 'rejected';
+        const note = noteParts.join(' ').trim();
+        let record;
+        try {
+            record = wctx.trajectory.reviewCorrectionSample(sampleId, normalizedDecision, note);
+            /* eslint-disable @typescript-eslint/no-unused-vars -- Reason: error handling only - returning failure response */
+        }
+        catch (error) {
+            return {
+                text: zh
+                    ? `审核样本失败：${sampleId}`
+                    : `Failed to review sample: ${sampleId}`,
+            };
+        }
+        return {
+            text: zh
+                ? `样本 ${record.sampleId} 已标记为 ${record.reviewStatus}。`
+                : `Sample ${record.sampleId} marked as ${record.reviewStatus}.`,
+        };
+    }
+    const samples = wctx.trajectory.listCorrectionSamples('pending');
+    if (samples.length === 0) {
+        return { text: zh ? '当前没有待审核纠错样本。' : 'No pending correction samples.' };
+    }
+    const lines = samples.map((sample) => `- ${sample.sampleId} | session=${sample.sessionId} | score=${sample.qualityScore}`);
+    return {
+        text: zh
+            ? `待审核纠错样本:\n${lines.join('\n')}`
+            : `Pending correction samples:\n${lines.join('\n')}`,
+    };
+}

package/dist/commands/strategy.d.ts

@@ -0,0 +1,2 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+export declare function handleInitStrategy(ctx: PluginCommandContext): PluginCommandResult;

package/dist/commands/strategy.js

@@ -0,0 +1,16 @@
+import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+export function handleInitStrategy(ctx) {
+    const workspaceDir = resolvePluginCommandWorkspaceDir(ctx, 'strategy');
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, ...ctx.config });
+    const okrDir = wctx.resolve('OKR_DIR').replace(workspaceDir, '').replace(/^\/+/, '');
+    const focusPath = wctx.resolve('CURRENT_FOCUS').replace(workspaceDir, '').replace(/^\/+/, '');
+    const userContextPath = wctx.resolve('USER_CONTEXT').replace(workspaceDir, '').replace(/^\/+/, '');
+    return {
+        text: `🎯 **Strategy Initialization**\n\n` +
+            `The Agent will now conduct a deep interview to establish your project's vision and strategic OKRs.\n\n` +
+            `**Instructions for Agent:** Read \`${okrDir}/\` for existing context. ` +
+            `Generate \`${focusPath}\` with the top 1-3 strategic focus areas based on the user interview. ` +
+            `Then update \`${userContextPath}\` with key user preferences discovered.`,
+    };
+}

package/dist/commands/thinking-os.d.ts

@@ -0,0 +1,2 @@
+import type { PluginCommandContext, PluginCommandResult } from '../openclaw-sdk.js';
+export declare function handleThinkingOs(ctx: PluginCommandContext): PluginCommandResult;