create-principles-disciple 1.104.2 → 1.106.0

package/plugin/dist/core/pd-config-loader.d.ts

@@ -1,96 +1,25 @@
-/**
- * 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 type { EffectivePdConfig } from '@principles/core/runtime-v2';
-export declare const PD_CONFIG_DIR = ".pd";
-export declare const PD_CONFIG_FILENAME = "config.yaml";
+import { type PluginConfigLoadResult } from '@principles/host-runtime';
+export { getPdConfigPath, loadFeatureFlagFromConfig, loadPdConfigForPlugin, PD_CONFIG_DIR, PD_CONFIG_FILENAME, } from '@principles/host-runtime';
+export type { PluginConfigLoadResult } from '@principles/host-runtime';
 export type ObserverReadiness = 'disabled' | 'needs_setup' | 'ready' | 'not_ready' | 'config_malformed';
 export interface ObserverConfigResult {
-    /** Whether the observer feature is enabled in config */
     enabled: boolean;
-    /** Observer readiness state */
     readiness: ObserverReadiness;
-    /** Config source: 'defaults' | 'user_config' | 'malformed' */
     source: string;
-    /** Reason for current state */
     reason: string;
-    /** What the user should do next */
     nextAction: string;
-    /** The runtime profile ID for this observer, if configured */
     runtimeProfileId: string | null;
-    /** The runtime profile type, if configured */
     runtimeProfileType: string | null;
-    /** The apiKeyEnv for the runtime profile, if applicable */
     apiKeyEnv: string | null;
-    /** Whether the apiKeyEnv is present in process.env */
     apiKeyPresent: boolean;
-    /** Provider name from runtime profile */
     provider: string | null;
-    /** Model name from runtime profile */
     model: string | null;
-    /** Timeout from runtime profile */
     timeoutMs: number | null;
-    /** Base URL from runtime profile */
     baseUrl: string | null;
-    /** Config validation errors (only present when readiness=config_malformed) */
-    configErrors?: Array<{
-        path: string;
-        reason: string;
-        nextAction: string;
-    }>;
+    configErrors?: PluginConfigLoadResult['errors'];
 }
-export interface PluginConfigLoadResult {
-    ok: boolean;
-    effective: EffectivePdConfig;
-    source: 'defaults' | 'user_config' | 'malformed';
-    configPath: string;
-    warnings: string[];
-    errors: Array<{
-        path: string;
-        reason: string;
-        nextAction: string;
-    }>;
-}
-export declare function getPdConfigPath(workspaceDir: string): string;
-/**
- * Load and validate `.pd/config.yaml` from the workspace.
- * Never throws on malformed input. Always provides a usable fallback.
- */
-export declare function loadPdConfigForPlugin(workspaceDir: string): PluginConfigLoadResult;
-/**
- * Get a single feature flag's enabled state from .pd/config.yaml.
- * Replaces the old `loadFeatureFlagFromWorkspace` which read .pd/feature-flags.yaml.
- */
-export declare function loadFeatureFlagFromConfig(workspaceDir: string, flagId: string, logger?: {
-    warn?: (msg: string) => void;
-    info?: (msg: string) => void;
-}): {
-    enabled: boolean;
-    source: string;
-};
-/**
- * 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 declare function resolveObserverConfig(workspaceDir: string, observerFlagId: string, observerAgentName: string, _logger?: {
-    warn?: (msg: string) => void;
-    info?: (msg: string) => void;
-    debug?: (msg: string) => void;
+    warn?: (message: string) => void;
+    info?: (message: string) => void;
+    debug?: (message: string) => void;
 }): ObserverConfigResult;

package/plugin/dist/core/principle-application-ledger.d.ts

@@ -0,0 +1,45 @@
+export type PrincipleApplicationLevel = 'effect' | 'presence';
+export type PrincipleApplicationKind = 'rule_blocked' | 'auto_correct_applied' | 'self_reported' | 'prompt_injected';
+export interface PrincipleApplicationInput {
+    principleId: string;
+    activationId?: string;
+    ruleId?: string;
+    channel: 'code_tool_hook' | 'prompt';
+    level: PrincipleApplicationLevel;
+    kind: PrincipleApplicationKind;
+    sessionId?: string;
+    toolName?: string;
+    filePath?: string;
+    digest?: string;
+}
+/**
+ * Record one application event. Returns true when a row was written (or
+ * deduped), false on failure — callers must surface the reason (rc-9).
+ */
+export declare function recordPrincipleApplication(workspaceDir: string, input: PrincipleApplicationInput): boolean;
+/**
+ * Align activation ids with the actually-injected principle subset (PRI-531
+ * review fix). Budget truncation can drop principles from the tail of the
+ * full list — pairing by raw index would attach the wrong activation_id to a
+ * presence row (rc-6-adjacent data pairing).
+ */
+export declare function alignActivationIds(principles: ReadonlyArray<{
+    principleId: string;
+    activationId?: string;
+}>, injectedIds: ReadonlySet<string>): string[];
+/**
+ * Presence rows for a prompt injection event — one per principle, deduped per
+ * session×principle by the partial unique index (restarts included).
+ * Returns the number of NEW rows written (0 when all were already present).
+ * Failures are warned via the optional logger (rc-9) — never thrown.
+ */
+export declare function recordInjectionPresence(workspaceDir: string, principleIds: readonly string[], sessionId: string | undefined, activationIds?: readonly string[], logger?: {
+    warn?: (message: string) => void;
+    info?: (message: string) => void;
+}): number;
+export declare function recordSelfReportFromText(workspaceDir: string, text: unknown, sessionId: string | undefined, logger?: {
+    warn?: (message: string) => void;
+    info?: (message: string) => void;
+}): number;
+/** Test hook: close cached connections and reset the retention sweep clock. */
+export declare function clearPrincipleApplicationLedgerCache(): void;

package/plugin/dist/core/principle-receipt-metadata.d.ts

@@ -0,0 +1,15 @@
+export interface PrincipleReceiptMetadata {
+    /** Resolved display title (fallback chain result; never empty). */
+    title: string;
+    /** Owner approval date (ISO string) — approvals.decided_at, fallback activations.activated_at. */
+    approvedAt?: string;
+    /** Source correction summary — only present when the artifact carries painReasonSummary. */
+    sourceSummary?: string;
+}
+/**
+ * Resolve receipt metadata for a blocked rule. Returns undefined when nothing
+ * useful can be resolved (caller degrades to the generic copy).
+ */
+export declare function loadPrincipleReceiptMetadata(workspaceDir: string, ruleId: string | undefined, principleId: string | undefined): PrincipleReceiptMetadata | undefined;
+/** Test hook: clear caches between tests. */
+export declare function clearPrincipleReceiptMetadataCache(): void;

package/plugin/dist/hooks/after-tool-call-helpers.d.ts

@@ -44,13 +44,17 @@ export declare function buildToolCallObservation(event: PluginHookAfterToolCallE
  */
 export declare function handleFrictionTrackingForFailure(sessionId: string, event: PluginHookAfterToolCallEvent, outcome: ToolCallOutcome, observation: ToolCallObservation, gfiBefore: number, workspaceDir: string, config: {
     get: (key: string) => unknown;
-}, wctx: WorkspaceContext): SessionState;
+}, wctx: WorkspaceContext, options?: {
+    recordTrajectory?: boolean;
+}): SessionState;
 /**
  * Handle friction relief and recording for a tool success.
  *
  * Relieves both tool_failure and dispatch_error GFI sources proportionally.
  */
-export declare function handleFrictionTrackingForSuccess(sessionId: string, event: PluginHookAfterToolCallEvent, outcome: ToolCallOutcome, observation: ToolCallObservation, gfiBefore: number, workspaceDir: string, wctx: WorkspaceContext): SessionState;
+export declare function handleFrictionTrackingForSuccess(sessionId: string, event: PluginHookAfterToolCallEvent, outcome: ToolCallOutcome, observation: ToolCallObservation, gfiBefore: number, workspaceDir: string, wctx: WorkspaceContext, options?: {
+    recordTrajectory?: boolean;
+}): SessionState;
 /**
  * Record hygiene tracking for memory/plan persistence actions on success.
  */

package/plugin/dist/hooks/gate-block-helper.d.ts

@@ -21,6 +21,10 @@ export interface BlockContext {
     sessionId?: string;
     /** Source module that triggered the block (for audit trail) */
     blockSource?: string;
+    /** RuleHost rule id — enables PRI-530 receipt copy attribution */
+    ruleId?: string;
+    /** Principle id from the rule result — enables PRI-530 receipt copy attribution */
+    principleId?: string;
 }
 /**
  * Single authoritative block helper.

package/plugin/dist/hooks/gate.d.ts

@@ -8,9 +8,38 @@
  * 1. Early Return: Skip if not write/bash/agent tool or no workspace
  * 2. Rule Host: Dynamic principle-based evaluation (sole gate)
  */
+import { WorkspaceContext } from '../core/workspace-context.js';
+import type { RuleContextV2 } from '@principles/core/runtime-v2';
 import type { PluginHookBeforeToolCallEvent, PluginHookToolContext, PluginHookBeforeToolCallResult, PluginLogger } from '../openclaw-sdk.js';
+import type { HostEventResult } from '@principles/core/host';
 export declare function handleBeforeToolCall(event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext & {
     workspaceDir?: string;
     pluginConfig?: Record<string, unknown>;
     logger?: Partial<PluginLogger>;
 }): PluginHookBeforeToolCallResult | void;
+export declare function buildOpenClawRuleInputEnrichment(event: PluginHookBeforeToolCallEvent, workspaceDir: string, sessionId: string | undefined): {
+    currentGfi: number;
+    recentThinking: boolean;
+    epTier: number;
+    bashRisk: "dangerous" | "normal" | "safe" | "unknown";
+};
+/**
+ * PRI-483 Phase 4 — Build RuleContextV2 for RuleHost.evaluate when the
+ * `rulecode_context_v2` feature flag is ON. Returns `undefined` when the flag
+ * is OFF (v1 zero-change — does NOT touch trajectory) or when config loading
+ * fails (conservative fail-soft: can't determine flag state → v1-style).
+ *
+ * ERR-024 prevention: context assembly failures never skip RuleHost.evaluate.
+ * - loadPdConfigForPlugin throws → return undefined (v1-style)
+ * - buildProductionRuleContext throws → return UNAVAILABLE_RULE_CONTEXT
+ *   (structured unavailable so v2 rules see "context unavailable" and allow)
+ *
+ * Spec: docs/superpowers/specs/2026-06-27-rulecode-context-vision-design.md §5.3
+ */
+export declare function buildRuleContextIfEnabled(wctx: WorkspaceContext, targetPath: string, sessionId: string | undefined, logger: {
+    warn?: (msg: string) => void;
+} | undefined): RuleContextV2 | undefined;
+export declare function handleSharedRuleHostResult(event: PluginHookBeforeToolCallEvent, ctx: PluginHookToolContext & {
+    workspaceDir: string;
+    logger?: Partial<PluginLogger>;
+}, result: HostEventResult): void;

package/plugin/dist/hooks/pain.d.ts

@@ -17,8 +17,17 @@
 import { WorkspaceContext } from '../core/workspace-context.js';
 import type { EvolutionLoopEvent } from '../core/evolution-types.js';
 import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
+import type { ProductionPainEnrichment } from '@principles/host-runtime';
+import type { HostEventResult } from '@principles/core/host';
 import { buildTrajectoryEvidence } from './trajectory-evidence.js';
 export { buildTrajectoryEvidence };
+/**
+ * Host-owned best-effort continuation after durable shared persistence.
+ * The hook may return once SQLite commits, while rejections remain observable
+ * and tests/shutdown code can explicitly drain scheduled work.
+ */
+export declare function schedulePainContinuation(workspaceDir: string, continuation: Promise<void>): void;
+export declare function drainPainContinuationsForTest(): Promise<void>;
 export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent, options?: {
     recordObservability?: boolean;
 }): Promise<void>;
@@ -33,3 +42,16 @@ export declare function handleAfterToolCall(event: PluginHookAfterToolCallEvent,
     workspaceDir?: string;
     pluginConfig?: Record<string, unknown>;
 }, api?: OpenClawPluginApi): void;
+/**
+ * OpenClaw-owned enrichment for the shared ordinary after-tool kernel.
+ * Session/GFI, event-log, probation, PROFILE and hygiene behavior stays here;
+ * the shared runtime owns classification/admission and the atomic trajectory write.
+ */
+export declare function prepareOrdinaryAfterToolCallForSharedRuntime(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
+    workspaceDir: string;
+    pluginConfig?: Record<string, unknown>;
+}): ProductionPainEnrichment;
+/** Restore OpenClaw-owned pain UX/diagnosis after the shared atomic evidence write. */
+export declare function handleSharedPainEvidenceResult(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
+    workspaceDir: string;
+}, result: HostEventResult): void;

package/plugin/dist/hooks/prompt.d.ts

@@ -1,6 +1,16 @@
-import type { PluginHookBeforePromptBuildEvent, PluginHookAgentContext, PluginHookBeforePromptBuildResult } from '../openclaw-sdk.js';
+import type { PluginHookBeforePromptBuildEvent, PluginHookAgentContext, PluginHookBeforePromptBuildResult, PluginLogger } from '../openclaw-sdk.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
 import type { ContextInjectionConfig } from '../types.js';
+import type { ActivePrinciplePromptResult } from '@principles/host-runtime';
 import type { PromptHookApi } from './prompt-types.js';
+import type { InjectablePrinciple } from '../core/principle-injection.js';
+export interface LegacyPrinciplePromptSelection {
+    active: InjectablePrinciple[];
+    probation: InjectablePrinciple[];
+    content: string;
+    selectedIds: ReadonlySet<string>;
+}
+export declare function selectLegacyPrinciplesForPrompt(workspaceDir: string, reducer: Pick<WorkspaceContext['evolutionReducer'], 'getActivePrinciples' | 'getProbationPrinciples'>, logger?: PluginLogger): LegacyPrinciplePromptSelection;
 /**
  * Reset all module-level prompt state for a workspace.
  * Intended for test isolation — call in beforeEach().
@@ -19,4 +29,4 @@ export declare function resetPromptStateForTest(workspaceDir?: string): void;
 export declare function loadContextInjectionConfig(workspaceDir: string): ContextInjectionConfig;
 export declare function handleBeforePromptBuild(event: PluginHookBeforePromptBuildEvent, ctx: PluginHookAgentContext & {
     api?: PromptHookApi;
-}): Promise<PluginHookBeforePromptBuildResult | void>;
+}, sharedActivePrinciplePrompt?: ActivePrinciplePromptResult, preparedLegacyPrinciples?: LegacyPrinciplePromptSelection): Promise<PluginHookBeforePromptBuildResult | void>;

package/plugin/dist/host-runtime/openclaw-host-runtime.d.ts

@@ -0,0 +1,19 @@
+import { type ActivePrinciplePromptResult, type HostRuntime, type ProductionRuleContextRequest, type ProductionPainEnrichment } from '@principles/host-runtime';
+import type { HostEventResult } from '@principles/core/host';
+import type { PluginHookAgentContext, PluginHookAfterToolCallEvent, PluginHookBeforePromptBuildEvent, PluginHookBeforePromptBuildResult, PluginHookBeforeToolCallEvent, PluginHookBeforeToolCallResult, PluginHookToolContext } from '../openclaw-sdk.js';
+export interface OpenClawHostRuntimeOptions {
+    beforePromptBuild(event: PluginHookBeforePromptBuildEvent, context: PluginHookAgentContext, prompt: ActivePrinciplePromptResult): Promise<PluginHookBeforePromptBuildResult | void>;
+    promptExcludePrincipleIds?(event: PluginHookBeforePromptBuildEvent, context: PluginHookAgentContext): ReadonlySet<string>;
+    ruleContextProvider?(event: PluginHookBeforeToolCallEvent, context: PluginHookToolContext, request: ProductionRuleContextRequest): unknown | Promise<unknown>;
+    ruleInputEnrichmentProvider?(event: PluginHookBeforeToolCallEvent, context: PluginHookToolContext, request: ProductionRuleContextRequest): unknown | Promise<unknown>;
+    onBeforeToolResult?(event: PluginHookBeforeToolCallEvent, context: PluginHookToolContext, result: HostEventResult): PluginHookBeforeToolCallResult | void;
+    painEnrichmentProvider?(event: PluginHookAfterToolCallEvent, context: PluginHookToolContext): ProductionPainEnrichment | Promise<ProductionPainEnrichment>;
+    onAfterToolResult?(event: PluginHookAfterToolCallEvent, context: PluginHookToolContext, result: HostEventResult): void | Promise<void>;
+}
+export interface OpenClawHostRuntime {
+    readonly runtime: HostRuntime;
+    dispatchBeforePromptBuild(event: PluginHookBeforePromptBuildEvent, context: PluginHookAgentContext): Promise<PluginHookBeforePromptBuildResult | void>;
+    dispatchBeforeToolCall(event: PluginHookBeforeToolCallEvent, context: PluginHookToolContext): Promise<PluginHookBeforeToolCallResult | void>;
+    dispatchAfterToolCall(event: PluginHookAfterToolCallEvent, context: PluginHookToolContext): Promise<void>;
+}
+export declare function createOpenClawHostRuntime(options: OpenClawHostRuntimeOptions): OpenClawHostRuntime;

package/plugin/dist/index.d.ts

@@ -40,6 +40,14 @@ export declare function shouldStartInternalizationAutoConsumer(workspaceDir: str
     info?: (msg: string) => void;
     warn?: (msg: string) => void;
 }): InternalizationAutoConsumerGateResult;
+export declare function shouldUseSharedHostRuntime(workspaceDir: string, logger: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+}): {
+    enabled: boolean;
+    source: string;
+    rollbackReason: string | null;
+};
 declare const plugin: {
     name: string;
     description: string;

package/plugin/dist/openclaw-sdk.d.ts

@@ -195,14 +195,28 @@ export interface PluginHookBeforePromptBuildResult {
 }
 export interface PluginHookBeforeToolCallEvent {
     toolName: string;
+    /** Host-provided tool call arguments (OpenClaw 2026.7.x sends `params`). */
     params?: Record<string, unknown>;
+    /** @deprecated Host sends `params`; kept for older adapter shims. */
     toolArgs?: Record<string, unknown>;
     agentId?: string;
     sessionId?: string;
     [key: string]: unknown;
 }
 export interface PluginHookBeforeToolCallResult {
+    /**
+     * Host merge contract (OpenClaw 2026.7.x, hook-before-tool-call-result.ts):
+     * only `params`, `block`, `blockReason`, `requireApproval` are read from the
+     * hook result. New code must use these fields.
+     */
+    params?: Record<string, unknown>;
+    block?: boolean;
+    blockReason?: string;
+    /** Shape is host-defined (approval request details). */
+    requireApproval?: unknown;
+    /** @deprecated Use `params`. Host does not read `toolArgs`. */
     toolArgs?: Record<string, unknown>;
+    /** @deprecated Blocking is expressed via `block: true`. Host does not read `skipToolCall`. */
     skipToolCall?: boolean;
     [key: string]: unknown;
 }
@@ -250,15 +264,21 @@ export interface PluginHookSubagentEndedEvent {
     [key: string]: unknown;
 }
 export interface PluginHookLlmOutputEvent {
-    output: string;
+    /**
+     * @deprecated Host (OpenClaw 2026.7.x) does not send `output`. It fires once
+     * per model-loop attempt with `assistantTexts` + `lastAssistant`; read those.
+     */
+    output?: string;
     agentId?: string;
     sessionId?: string;
     runId?: string;
     provider?: string;
     model?: string;
     usage?: TokenUsage;
+    /** Host-provided full assistant texts for this model-loop attempt. */
     assistantTexts?: string[];
     trigger?: string;
+    /** Last complete assistant message object (host-defined shape). */
     lastAssistant?: unknown;
     [key: string]: unknown;
 }
@@ -314,6 +334,8 @@ export interface PluginHookBeforeMessageWriteResult {
         role?: string;
         content?: unknown;
     };
+    /** Host contract: `block: true` prevents the transcript write entirely. */
+    block?: boolean;
     [key: string]: unknown;
 }
 export interface OpenClawPluginHttpRouteParams {

package/plugin/dist/openclaw.plugin.json

@@ -9,7 +9,6 @@
     ]
   },
   "skills": [
-    "templates/langs/en/skills",
     "templates/langs/zh/skills"
   ],
   "configSchema": {

package/plugin/openclaw.plugin.json

@@ -2,14 +2,13 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Turn repeated Agent corrections into Owner-approved, observable, reversible behavior principles. Stop correcting the same AI behavior across sessions.",
-  "version": "1.202.1",
+  "version": "1.207.1",
   "activation": {
     "onCapabilities": [
       "hook"
     ]
   },
   "skills": [
-    "templates/langs/en/skills",
     "templates/langs/zh/skills"
   ],
   "configSchema": {

package/plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.202.1",
+  "version": "1.207.1",
   "description": "Turn repeated Agent corrections into Owner-approved, observable, reversible behavior principles. Stop correcting the same AI behavior across sessions.",
   "type": "module",
   "main": "./dist/index.js",
@@ -62,6 +62,7 @@
     "test": "vitest run",
     "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:host-runtime-parity": "vitest run --config vitest.parity.config.ts tests/bdd/openclaw-shared-host-runtime-parity.steps.test.ts tests/package/published-host-runtime-bundle.test.ts",
     "test:coverage": "vitest run --coverage",
     "test:all": "vitest run",
     "lint": "eslint \"src/**/*.ts\"",

package/plugin/scripts/sync-plugin.mjs

@@ -686,24 +686,33 @@ function syncFilteredManifest(lang) {
         process.exit(1);
     }
 
-    const filtered = manifest.skills.filter(sp => {
-        if (typeof sp !== 'string') return false;
-        return sp.includes(`/langs/${selectedLang}/`);
-    });
+    // PR #1332 companion: the source manifest declares exactly one root
+    // (zh, product default). REPLACE language roots with the selected one
+    // instead of only filtering, so `--lang en` works against a zh-default
+    // source manifest. Mirrors the production transform in
+    // create-principles-disciple/src/skill-language.ts.
+    const langRoots = {
+        zh: 'templates/langs/zh/skills',
+        en: 'templates/langs/en/skills',
+    };
+    const isLangRoot = (sp) =>
+        typeof sp === 'string' &&
+        (sp.replaceAll('\\', '/') === langRoots.zh || sp.replaceAll('\\', '/') === langRoots.en);
 
-    if (filtered.length === 0) {
-        console.error(`❌ No skills match language "${selectedLang}" in source manifest`);
+    if (!existsSync(join(SOURCE_DIR, langRoots[selectedLang]))) {
+        console.error(`❌ Skill templates missing for language "${selectedLang}": ${langRoots[selectedLang]}`);
         process.exit(1);
     }
 
-    manifest.skills = filtered;
+    const kept = manifest.skills.filter((sp) => !isLangRoot(sp));
+    manifest.skills = [...kept, langRoots[selectedLang]];
 
     // Use syncItem semantics: remove target, then write freshly
     if (existsSync(targetPath)) {
         rmSync(targetPath, { force: true });
     }
     writeFileSync(targetPath, JSON.stringify(manifest, null, 2) + '\n', 'utf-8');
-    console.log(`  ✅ skills filtered to lang: ${selectedLang} (${filtered.length} path(s))`);
+    console.log(`  ✅ skills filtered to lang: ${selectedLang} (${manifest.skills.length} path(s))`);
 }
 
 /**

package/plugin/scripts/verify-build.mjs

@@ -94,14 +94,25 @@ for (const [path, config] of Object.entries(expectedCounts)) {
   }
 }
 
-// 3. List skill files for visibility (agents migrated to skills in templates/)
-const skillsDir = join(rootDir, 'dist/templates/langs/zh/skills');
-if (existsSync(skillsDir)) {
-  const skillFiles = readdirSync(skillsDir)
-    .filter(f => f.endsWith('.md'));
-  
-  if (skillFiles.length > 0) {
-    console.log(`\n📦 Skills available: ${skillFiles.length} (in dist/templates/langs/zh/skills/)`);
+// 3. Verify skill template roots for BOTH languages ship in dist — the
+// installer rewrites the installed manifest per --lang (PR #1332 companion),
+// so a missing root breaks install-time language selection. A "publishable"
+// skill is an immediate child directory containing SKILL.md (what OpenClaw
+// links into ~/.openclaw/plugin-skills).
+for (const lang of ['zh', 'en']) {
+  const skillsDir = join(rootDir, 'dist/templates/langs', lang, 'skills');
+  if (!existsSync(skillsDir)) {
+    console.error(`❌ Missing skill templates: dist/templates/langs/${lang}/skills`);
+    hasError = true;
+    continue;
+  }
+  const publishable = readdirSync(skillsDir, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && existsSync(join(skillsDir, e.name, 'SKILL.md')));
+  if (publishable.length < 20) {
+    console.error(`❌ dist/templates/langs/${lang}/skills has only ${publishable.length} publishable skills (expected at least 20)`);
+    hasError = true;
+  } else {
+    console.log(`✅ ${lang} skills: ${publishable.length} (dist/templates/langs/${lang}/skills/)`);
   }
 }