create-principles-disciple 1.95.0 → 1.97.0

package/console/dist/ui/utils/agent-metadata.js

@@ -0,0 +1,275 @@
+/**
+ * Agent Metadata — Control Center agent grouping & role descriptions
+ *
+ * Pure data module (no React, no I/O). Defines:
+ * - Which dependency cluster each of the 9 internal agents belongs to
+ * - Bilingual role / detail / impact / tech-detail text for progressive disclosure
+ * - Whether toggling the agent off requires inline confirmation (isCore)
+ *
+ * Content source: design-prototype/control-center.html (approved prototype).
+ * Agent names match INTERNAL_AGENT_NAMES from @principles/core (camelCase).
+ *
+ * ERR entries:
+ * - rc-1: pure static data, no untrusted input
+ * - rc-2: no `as` bypasses
+ * - rc-5: consumers use Object.hasOwn() to look up metadata by agent name
+ */
+// ── Group order (matches render order on the page) ───────────────────────────
+export const GROUP_ORDER = [
+    'core_trio',
+    'code_chain',
+    'quality_polish',
+    'sidechain',
+];
+// ── Group metadata ───────────────────────────────────────────────────────────
+export const AGENT_GROUPS = [
+    {
+        id: 'core_trio',
+        labelZh: '核心三件套',
+        labelEn: 'Core Trio',
+        tag: 'must',
+        tagLabelZh: '必须一起开',
+        tagLabelEn: 'Must together',
+        hintZh: '关掉任何一个，PD 都无法把错误转化为原则',
+        hintEn: 'Disabling any one breaks the error-to-principle pipeline',
+    },
+    {
+        id: 'code_chain',
+        labelZh: '代码实现链',
+        labelEn: 'Code Chain',
+        tag: 'recommend',
+        tagLabelZh: '推荐一起开',
+        tagLabelEn: 'Recommend together',
+        hintZh: '只开 artificer 会降级为纯提示通道；只开 evaluator 无意义',
+        hintEn: 'Only artificer degrades to prompt-only; only evaluator is meaningless',
+    },
+    {
+        id: 'quality_polish',
+        labelZh: '质量打磨',
+        labelEn: 'Quality Polish',
+        tag: 'optional',
+        tagLabelZh: '可选 · 单独开关',
+        tagLabelEn: 'Optional · toggle individually',
+        hintZh: '让原则更精炼，关掉也能用，只是质量略粗',
+        hintEn: 'Refines principles; disabling is fine, just slightly rougher quality',
+    },
+    {
+        id: 'sidechain',
+        labelZh: '侧链服务',
+        labelEn: 'Sidechain',
+        tag: 'independent',
+        tagLabelZh: '独立 · 单独开关',
+        tagLabelEn: 'Independent · toggle individually',
+        hintZh: '不影响主管道，只影响 pain 信号检测精度',
+        hintEn: 'Does not affect the main pipeline; only pain signal detection precision',
+    },
+];
+// ── Agent metadata (covers all 9 INTERNAL_AGENT_NAMES) ───────────────────────
+export const AGENT_METADATA = {
+    diagnostician: {
+        name: 'diagnostician',
+        group: 'core_trio',
+        displayNameZh: '诊断师',
+        displayNameEn: 'Diagnostician',
+        roleZh: '问"为什么会出错"，找到根本原因',
+        roleEn: 'Asks "why did it go wrong" and finds the root cause',
+        detailZh: '当 Agent 做错了什么，诊断师负责像事故复盘一样追问"为什么"，找到根本原因，而不是只记下"出错了"。然后把原因抽象成一条原则候选。\n\n它其实是 3 个子阶段串联：找根因 → 抽象原则 → 决定怎么处理。',
+        detailEn: 'When an Agent makes a mistake, the Diagnostician runs a post-mortem asking "why" to find the root cause — not just recording "it failed". It then abstracts the cause into a principle candidate.\n\nIt is actually 3 sub-stages chained: find root cause → abstract principle → decide how to handle.',
+        impactLevel: 'danger',
+        impactZh: 'Pain 信号无法进入内化管道。诊断是入口，关掉后整个流程瘫痪，无法生成新的原则候选。',
+        impactEn: 'Pain signals cannot enter the internalization pipeline. Diagnosis is the entry point; disabling paralyzes the entire flow — no new principle candidates can be generated.',
+        techDetailZh: {
+            '输入': '`DiagnosticianContextPayload`（pain 信号上下文）',
+            '输出': '`DiagnosticianOutputV1` · rootCause / violatedPrinciples / recommendations[] / confidence',
+            '编排': '由 `PainSignalBridge` 触发；`diagnostician_split_pipeline` flag 控制单体 vs 3 段拆分',
+            '阶段': '`diag_rootcause` → `diag_distiller` → `diag_router`',
+        },
+        techDetailEn: {
+            'Input': '`DiagnosticianContextPayload` (pain signal context)',
+            'Output': '`DiagnosticianOutputV1` · rootCause / violatedPrinciples / recommendations[] / confidence',
+            'Orchestration': 'Triggered by `PainSignalBridge`; `diagnostician_split_pipeline` flag controls monolithic vs 3-stage split',
+            'Stages': '`diag_rootcause` → `diag_distiller` → `diag_router`',
+        },
+        isCore: true,
+    },
+    dreamer: {
+        name: 'dreamer',
+        group: 'core_trio',
+        displayNameZh: '梦想家',
+        displayNameEn: 'Dreamer',
+        roleZh: '想出 2-3 种不同的纠正方案',
+        roleEn: 'Proposes 2-3 distinct correction options',
+        detailZh: '诊断完成后，梦想家从不同角度提出多个纠正方案——就像 brainstorming，先发散再收敛。每个方案都包含"当时做错了什么 / 应该怎么做 / 为什么"。\n\n它是内化引擎的第一站，接收诊断产物，输出候选方案。',
+        detailEn: 'After diagnosis, the Dreamer proposes multiple correction options from different angles — like brainstorming, diverge first then converge. Each option includes "what went wrong / what should be done / why".\n\nIt is the first stop of the internalization engine, receiving diagnosis output and producing candidates.',
+        impactLevel: 'danger',
+        impactZh: '内化引擎失去入口。Dreamer 是链首，关掉后无候选方案生成，内化瘫痪。',
+        impactEn: 'The internalization engine loses its entry point. Dreamer is the chain head; disabling means no candidates are generated — internalization is paralyzed.',
+        techDetailZh: {
+            '输入': '诊断阶段的 distilled principle / candidate artifact',
+            '输出': '`DreamerOutput` · 1-5 个候选，每个含 badDecision / betterDecision / riskLevel / strategicPerspective',
+            '注意': '`InternalizationAutoConsumerService` 当前仅自动消费 dreamer，下游需手动触发',
+        },
+        techDetailEn: {
+            'Input': 'Distilled principle / candidate artifact from the diagnosis stage',
+            'Output': '`DreamerOutput` · 1-5 candidates, each with badDecision / betterDecision / riskLevel / strategicPerspective',
+            'Note': '`InternalizationAutoConsumerService` currently only auto-consumes dreamer; downstream must be triggered manually',
+        },
+        isCore: true,
+    },
+    scribe: {
+        name: 'scribe',
+        group: 'core_trio',
+        displayNameZh: '抄写员',
+        displayNameEn: 'Scribe',
+        roleZh: '把方案写成正式的原则条文',
+        roleEn: 'Writes the chosen option into a formal principle statement',
+        detailZh: '梦想家给出多个方案后，抄写员负责把选中的方案转写成清晰、可执行的原则条文——就像把会议纪要整理成正式文档。\n\n这条原则文本是后续所有工作的承载者：评估员会反向溯源到这里做质量校验。',
+        detailEn: 'After the Dreamer proposes multiple options, the Scribe transforms the selected one into a clear, executable principle statement — like turning meeting notes into a formal document.\n\nThis principle text is the carrier for all downstream work: the Evaluator traces back here for quality checks.',
+        impactLevel: 'danger',
+        impactZh: '无原则文本产出。Scribe 是原则承载者，关掉后管道断裂，核心瘫痪。',
+        impactEn: 'No principle text is produced. Scribe is the principle carrier; disabling breaks the pipeline — core is paralyzed.',
+        techDetailZh: {
+            '输入': 'Philosopher artifact（或 dreamer 直连）',
+            '输出': '`ScribeOutputV1` · principleDraft + sourcePhilosopherArtifactId（lineage 强制校验）',
+            '语言': '支持 Owner 偏好语言（`outputLanguage`，PRI-336）',
+        },
+        techDetailEn: {
+            'Input': 'Philosopher artifact (or direct from dreamer)',
+            'Output': '`ScribeOutputV1` · principleDraft + sourcePhilosopherArtifactId (lineage enforced)',
+            'Language': 'Supports Owner preferred language (`outputLanguage`, PRI-336)',
+        },
+        isCore: true,
+    },
+    artificer: {
+        name: 'artificer',
+        group: 'code_chain',
+        displayNameZh: '工匠',
+        displayNameEn: 'Artificer',
+        roleZh: '把原则变成可执行的拦截代码',
+        roleEn: 'Turns the principle into executable interception code',
+        detailZh: '原则写好后，工匠负责把它变成代码——一个 `evaluate()` 函数，会在 Agent 发起工具调用时拦截检查。这比"提示词"更刚性、更可靠。\n\n同时生成 golden trace 测试用例，确保代码行为符合预期。',
+        detailEn: 'Once the principle is written, the Artificer turns it into code — an `evaluate()` function that intercepts and checks Agent tool calls. This is more rigid and reliable than "prompt wording".\n\nIt also generates golden trace test cases to ensure the code behaves as intended.',
+        impactLevel: 'amber',
+        impactZh: '降级运行。退回纯 prompt 通道，principle 文本仍可内化，但无 RuleHost 实现代码。',
+        impactEn: 'Degraded mode. Falls back to prompt-only channel; principle text can still be internalized, but no RuleHost implementation code.',
+        techDetailZh: {
+            '输入': 'Scribe artifact（principleDraft）',
+            '输出': '`ArtificerRuleOutput` · implementationCode + goldenTraceCases + affectedTools',
+            '信任边界': 'activation-capable，LLM 输出作 `unknown` 处理，validateOutput + lineage 通过才 commit',
+            'L2 模式': '`rulehost-code-generation` flag 开启 write-test-fix 循环（沙盒回放 → 重试，最多 3 次）',
+        },
+        techDetailEn: {
+            'Input': 'Scribe artifact (principleDraft)',
+            'Output': '`ArtificerRuleOutput` · implementationCode + goldenTraceCases + affectedTools',
+            'Trust boundary': 'activation-capable; LLM output treated as `unknown`; commit only after validateOutput + lineage pass',
+            'L2 mode': '`rulehost-code-generation` flag enables write-test-fix loop (sandbox replay → retry, max 3)',
+        },
+        isCore: true,
+    },
+    evaluator: {
+        name: 'evaluator',
+        group: 'code_chain',
+        displayNameZh: '评估员',
+        displayNameEn: 'Evaluator',
+        roleZh: '审查原则和代码质量，决定能否生效',
+        roleEn: 'Reviews principle & code quality, decides whether it can activate',
+        detailZh: '工匠写完代码后，评估员做质量审查：原则是否清晰？代码是否符合原则意图？有没有覆盖足够多的场景？\n\n给出 approved / needs_revision / rejected 决策。只有 approved 的原则才能通过 RuleHost 通道激活。',
+        detailEn: 'After the Artificer writes the code, the Evaluator does a quality review: is the principle clear? Does the code match the principle intent? Does it cover enough scenarios?\n\nIt returns an approved / needs_revision / rejected decision. Only approved principles can activate via the RuleHost channel.',
+        impactLevel: 'amber',
+        impactZh: '降级运行。Principle 仍写入，但无 validated 标记，RuleHost 通道无法激活。',
+        impactEn: 'Degraded mode. Principle is still written, but without the validated mark — RuleHost channel cannot activate.',
+        techDetailZh: {
+            '输入': 'Artificer artifact + Scribe artifact（反向溯源 principle 文本）',
+            '输出': '`EvaluatorOutputV1/V2` · decision + score + strengths/concerns + codeReview',
+            'V2 模式': '运行 adversarial sandbox replay，通过则持久化 `artifactKind: "rule"` artifact',
+        },
+        techDetailEn: {
+            'Input': 'Artificer artifact + Scribe artifact (reverse-traces principle text)',
+            'Output': '`EvaluatorOutputV1/V2` · decision + score + strengths/concerns + codeReview',
+            'V2 mode': 'Runs adversarial sandbox replay; on pass, persists `artifactKind: "rule"` artifact',
+        },
+        isCore: true,
+    },
+    philosopher: {
+        name: 'philosopher',
+        group: 'quality_polish',
+        displayNameZh: '哲学家',
+        displayNameEn: 'Philosopher',
+        roleZh: '从多个方案中选出最优并精炼',
+        roleEn: 'Selects the best option from multiple candidates and refines it',
+        detailZh: '梦想家给出多个方案后，哲学家负责收敛——选出最优的一个，精炼成单一原则候选。\n\n关掉它，梦想家的产出会直接交给抄写员，原则可能略粗糙，但人工审批时仍可修改。',
+        detailEn: 'After the Dreamer proposes multiple options, the Philosopher converges — selects the best one and refines it into a single principle candidate.\n\nDisabling it means the Dreamer output goes directly to the Scribe; principles may be slightly rougher, but can still be edited during Owner review.',
+        impactLevel: 'green',
+        impactZh: '无影响。Dreamer 产出直接给 Scribe，质量略粗但人工审批可纠正。属设计预期。',
+        impactEn: 'No impact. Dreamer output goes directly to Scribe; slightly rougher quality but Owner review can correct. This is by design.',
+        techDetailZh: {
+            'MVP 状态': 'MVP-Quiet（ADR-0014 §2.5）。默认关闭，代码保留。',
+            '输出': '`PhilosopherOutputV1` · principleCandidate + sourceDreamerArtifactId',
+        },
+        techDetailEn: {
+            'MVP status': 'MVP-Quiet (ADR-0014 §2.5). Off by default; code retained.',
+            'Output': '`PhilosopherOutputV1` · principleCandidate + sourceDreamerArtifactId',
+        },
+        isCore: false,
+        mvpNoteZh: 'MVP-Quiet（ADR-0014 §2.5）。默认关闭，代码保留。',
+        mvpNoteEn: 'MVP-Quiet (ADR-0014 §2.5). Off by default; code retained.',
+    },
+    rolloutReviewer: {
+        name: 'rolloutReviewer',
+        group: 'quality_polish',
+        displayNameZh: '上线评审员',
+        displayNameEn: 'Rollout Reviewer',
+        roleZh: '原则生效前的最后一道审查',
+        roleEn: 'Final review before a principle goes live',
+        detailZh: '评估员通过后，上线评审员做最终把关——评估上线风险、安全检查，决定是否真的推向 rollout。\n\n它本就是 MVP-Quiet 默认关闭的，关掉不影响任何功能。',
+        detailEn: 'After the Evaluator passes, the Rollout Reviewer does the final gate — assessing rollout risks and safety checks, deciding whether to actually push to rollout.\n\nIt is already MVP-Quiet (off by default); disabling does not affect any functionality.',
+        impactLevel: 'green',
+        impactZh: '无影响。本就是 MVP-Quiet 默认关闭。',
+        impactEn: 'No impact. Already MVP-Quiet (off by default).',
+        techDetailZh: {
+            'MVP 状态': 'MVP-Quiet。不在 `MVP_CORE_TASK_KINDS` 白名单中。',
+            '输出': '`RolloutReviewerOutputV1` · approve_rollout / needs_revision / reject + rolloutRisks + safetyChecks',
+            '实现': '唯一不继承 `BasePeerRunner` 的 peer runner',
+        },
+        techDetailEn: {
+            'MVP status': 'MVP-Quiet. Not in the `MVP_CORE_TASK_KINDS` whitelist.',
+            'Output': '`RolloutReviewerOutputV1` · approve_rollout / needs_revision / reject + rolloutRisks + safetyChecks',
+            'Implementation': 'The only peer runner that does not extend `BasePeerRunner`',
+        },
+        isCore: false,
+        mvpNoteZh: 'MVP-Quiet。不在 MVP_CORE_TASK_KINDS 白名单中。',
+        mvpNoteEn: 'MVP-Quiet. Not in the MVP_CORE_TASK_KINDS whitelist.',
+    },
+    correctionObserver: {
+        name: 'correctionObserver',
+        group: 'sidechain',
+        displayNameZh: '纠正观察员',
+        displayNameEn: 'Correction Observer',
+        roleZh: '后台优化"纠错关键词"，减少误报',
+        roleEn: 'Background optimizer for "correction keywords", reducing false positives',
+        detailZh: 'PD 用一组关键词检测 Agent 是否在被纠正。但关键词会过时或误报。纠正观察员定期审查历史，自动调整关键词权重，衰减误报。\n\n它在后台每 15 分钟跑一次，不影响主管道。',
+        detailEn: 'PD uses a set of keywords to detect whether an Agent is being corrected. But keywords go stale or produce false positives. The Correction Observer periodically reviews history, auto-adjusting keyword weights and decaying false positives.\n\nIt runs in the background every 15 minutes and does not affect the main pipeline.',
+        impactLevel: 'amber',
+        impactZh: '纠错关键词停止自优化。确定性 pain 检测仍工作，但误报会逐步累积。',
+        impactEn: 'Correction keywords stop self-optimizing. Deterministic pain detection still works, but false positives gradually accumulate.',
+        techDetailZh: {},
+        techDetailEn: {},
+        isCore: true,
+    },
+    empathyObserver: {
+        name: 'empathyObserver',
+        group: 'sidechain',
+        displayNameZh: '共情观察员',
+        displayNameEn: 'Empathy Observer',
+        roleZh: '从用户语气中捕捉传统检测漏掉的挫败感',
+        roleEn: 'Catches frustration that traditional detection misses',
+        detailZh: '传统 pain 检测只能抓"命令失败""抛异常"这类硬错误。但用户说"又来了""怎么还是这样"时，其实已经很不满意了——这种情感摩擦硬检测抓不到。\n\n共情观察员用语义分析实时捕捉这类信号，弥补检测盲区。',
+        detailEn: 'Traditional pain detection only catches hard errors like "command failed" or "exception thrown". But when a user says "here we go again" or "why is this still happening", they are already frustrated — this emotional friction is invisible to hard detection.\n\nThe Empathy Observer uses semantic analysis to catch these signals in real time, covering the detection blind spot.',
+        impactLevel: 'amber',
+        impactZh: '退回纯确定性 pain 检测。常规对话下 pain 触发稀疏，内化速度显著下降。',
+        impactEn: 'Falls back to deterministic-only pain detection. In normal conversation, pain triggers become sparse — internalization speed drops significantly.',
+        techDetailZh: {},
+        techDetailEn: {},
+        isCore: true,
+    },
+};

package/console/dist/ui/utils/control-center-helpers.d.ts

@@ -13,6 +13,7 @@
  * - ERR-045: ANY-segment redaction for sensitive keys
  */
 import type { ReadinessStatus } from '../api.js';
+import { AGENT_METADATA, type AgentGroup } from './agent-metadata.js';
 export interface RedactedRuntimeProfileSummary {
     id: string;
     type: string;
@@ -57,4 +58,22 @@ export declare function getReadinessBadgeVariant(readiness: ReadinessStatus): 'd
 export declare function getReadinessLabel(readiness: ReadinessStatus): string;
 export declare function computeOverallReadiness(diag: ControlCenterDiagnostics): ReadinessStatus;
 export declare function groupAgentsByReadiness(diag: ControlCenterDiagnostics): Record<ReadinessStatus, RedactedAgentSummary[]>;
+export type AgentDependencyGroups = Record<AgentGroup, RedactedAgentSummary[]>;
+/**
+ * Type guard: is `name` a known internal agent with metadata?
+ * Replaces `as keyof typeof AGENT_METADATA` (rc-2: no `as` bypass).
+ */
+export declare function isKnownAgentName(name: string): name is keyof typeof AGENT_METADATA;
+/**
+ * Group agents by dependency cluster (core_trio / code_chain / quality_polish / sidechain).
+ * Agents not found in AGENT_METADATA go to the `unknown` bucket for fail-loud
+ * handling by the caller (rc-5: Object.hasOwn lookup; rc-9: no silent fallback).
+ *
+ * Group insertion order matches GROUP_ORDER (core_trio → code_chain → quality_polish → sidechain),
+ * so Object.keys(groups) returns the render order.
+ */
+export declare function groupAgentsByDependency(agents: RedactedAgentSummary[]): {
+    groups: AgentDependencyGroups;
+    unknown: RedactedAgentSummary[];
+};
 export declare function redactDiagnosticsForCopy(diag: ControlCenterDiagnostics): string;

package/console/dist/ui/utils/control-center-helpers.js

@@ -12,6 +12,7 @@
  * - ERR-014/ERR-016/ERR-017: Safe serialization for diagnostics copy
  * - ERR-045: ANY-segment redaction for sensitive keys
  */
+import { AGENT_METADATA } from './agent-metadata.js';
 // ── Readiness Badge Variant ──────────────────────────────────────────────────
 export function getReadinessBadgeVariant(readiness) {
     switch (readiness) {
@@ -70,6 +71,42 @@ export function groupAgentsByReadiness(diag) {
     }
     return groups;
 }
+/**
+ * Type guard: is `name` a known internal agent with metadata?
+ * Replaces `as keyof typeof AGENT_METADATA` (rc-2: no `as` bypass).
+ */
+export function isKnownAgentName(name) {
+    return Object.hasOwn(AGENT_METADATA, name);
+}
+/**
+ * Group agents by dependency cluster (core_trio / code_chain / quality_polish / sidechain).
+ * Agents not found in AGENT_METADATA go to the `unknown` bucket for fail-loud
+ * handling by the caller (rc-5: Object.hasOwn lookup; rc-9: no silent fallback).
+ *
+ * Group insertion order matches GROUP_ORDER (core_trio → code_chain → quality_polish → sidechain),
+ * so Object.keys(groups) returns the render order.
+ */
+export function groupAgentsByDependency(agents) {
+    const groups = {
+        core_trio: [],
+        code_chain: [],
+        quality_polish: [],
+        sidechain: [],
+    };
+    const unknown = [];
+    for (const agent of agents) {
+        // rc-5: Object.hasOwn for untrusted keys (agent.name comes from server response)
+        if (isKnownAgentName(agent.name)) {
+            const meta = AGENT_METADATA[agent.name];
+            groups[meta.group].push(agent);
+        }
+        else {
+            // rc-9: unknown agents go to a separate bucket; caller decides how to surface
+            unknown.push(agent);
+        }
+    }
+    return { groups, unknown };
+}
 // ── Redacted Diagnostics for Copy ────────────────────────────────────────────
 /** Maximum items per section in diagnostics output (ERR-014/ERR-016/ERR-017) */
 const MAX_ITEMS_PER_SECTION = 50;

package/console/dist/ui/utils/validators.d.ts

@@ -19,6 +19,7 @@
 export interface ErrorResponse {
     error?: string;
     message?: string;
+    reason?: string;
     nextAction?: string;
 }
 export declare function validateErrorResponse(v: unknown): ErrorResponse | null;
@@ -567,3 +568,39 @@ export interface IntentSummaryData {
 export declare function validateIntentWarning(v: unknown): IntentDocWarningData | null;
 export declare function validateIntentSections(v: unknown): IntentSectionsData | null;
 export declare function validateIntentSummary(v: unknown): IntentSummaryData | null;
+export interface IntentRawContentData {
+    content: string;
+    path: string;
+}
+export declare function validateIntentRawContent(v: unknown): IntentRawContentData | null;
+export interface IntentInitResultData {
+    ok: boolean;
+    created: boolean;
+    path?: string;
+    reason?: string;
+    nextAction?: string;
+}
+export interface IntentSaveResultData {
+    ok: boolean;
+    saved: boolean;
+    path?: string;
+    contentHash?: string;
+    lastEditedAt?: string;
+    warnings?: IntentDocWarningData[];
+    reason?: string;
+    nextAction?: string;
+}
+export declare function validateIntentInitResult(v: unknown): IntentInitResultData | null;
+export declare function validateIntentSaveResult(v: unknown): IntentSaveResultData | null;
+export interface IntentVersionEntry {
+    id: string;
+    lang: string;
+    contentHash: string;
+    contentSnapshot: string;
+    reason: string;
+    createdAt: string;
+}
+export interface IntentVersionData {
+    versions: IntentVersionEntry[];
+}
+export declare function validateIntentVersions(v: unknown): IntentVersionData | null;

package/console/dist/ui/utils/validators.js

@@ -62,6 +62,14 @@ export function validateErrorResponse(v) {
     if (Object.hasOwn(v, 'error') && isString(v.error)) {
         result.error = v.error;
     }
+    // N4 (PR-1083 review): surfacing the machine-readable `reason` field lets
+    // the UI branch on structured error codes instead of parsing natural
+    // language out of nextAction. Previously `nextAction.includes("32KB")`
+    // would silently regress to "saveFailed" the moment the backend phrased
+    // the cap differently or returned localized text.
+    if (Object.hasOwn(v, 'reason') && isString(v.reason)) {
+        result.reason = v.reason;
+    }
     if (Object.hasOwn(v, 'nextAction') && isString(v.nextAction)) {
         result.nextAction = v.nextAction;
     }
@@ -1626,3 +1634,125 @@ export function validateIntentSummary(v) {
     }
     return result;
 }
+export function validateIntentRawContent(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'content') || !isString(v.content))
+        return null;
+    if (!Object.hasOwn(v, 'path') || !isString(v.path))
+        return null;
+    return { content: v.content, path: v.path };
+}
+export function validateIntentInitResult(v) {
+    if (!isObject(v))
+        return null;
+    // Required fields
+    if (!Object.hasOwn(v, 'ok') || !isBoolean(v.ok))
+        return null;
+    if (!Object.hasOwn(v, 'created') || !isBoolean(v.created))
+        return null;
+    const result = {
+        ok: v.ok,
+        created: v.created,
+    };
+    // Optional fields
+    const path = readNullableString(v, 'path');
+    if (!path.valid)
+        return null;
+    if (path.value !== null)
+        result.path = path.value;
+    const reason = readNullableString(v, 'reason');
+    if (!reason.valid)
+        return null;
+    if (reason.value !== null)
+        result.reason = reason.value;
+    const nextAction = readNullableString(v, 'nextAction');
+    if (!nextAction.valid)
+        return null;
+    if (nextAction.value !== null)
+        result.nextAction = nextAction.value;
+    return result;
+}
+export function validateIntentSaveResult(v) {
+    if (!isObject(v))
+        return null;
+    // Required fields
+    if (!Object.hasOwn(v, 'ok') || !isBoolean(v.ok))
+        return null;
+    if (!Object.hasOwn(v, 'saved') || !isBoolean(v.saved))
+        return null;
+    const result = {
+        ok: v.ok,
+        saved: v.saved,
+    };
+    // Optional fields
+    const path = readNullableString(v, 'path');
+    if (!path.valid)
+        return null;
+    if (path.value !== null)
+        result.path = path.value;
+    const contentHash = readNullableString(v, 'contentHash');
+    if (!contentHash.valid)
+        return null;
+    if (contentHash.value !== null)
+        result.contentHash = contentHash.value;
+    const lastEditedAt = readNullableString(v, 'lastEditedAt');
+    if (!lastEditedAt.valid)
+        return null;
+    if (lastEditedAt.value !== null)
+        result.lastEditedAt = lastEditedAt.value;
+    const reason = readNullableString(v, 'reason');
+    if (!reason.valid)
+        return null;
+    if (reason.value !== null)
+        result.reason = reason.value;
+    const nextAction = readNullableString(v, 'nextAction');
+    if (!nextAction.valid)
+        return null;
+    if (nextAction.value !== null)
+        result.nextAction = nextAction.value;
+    if (Object.hasOwn(v, 'warnings')) {
+        if (!Array.isArray(v.warnings))
+            return null;
+        const warnings = validateArray(v.warnings, validateIntentWarning);
+        if (warnings === null)
+            return null;
+        result.warnings = warnings;
+    }
+    return result;
+}
+function validateIntentVersionEntry(v) {
+    if (!isObject(v))
+        return null;
+    // Required string fields — fail loud on missing or wrong type (rc-3, rc-4)
+    if (!Object.hasOwn(v, 'id') || !isString(v.id))
+        return null;
+    if (!Object.hasOwn(v, 'lang') || !isString(v.lang))
+        return null;
+    if (!Object.hasOwn(v, 'contentHash') || !isString(v.contentHash))
+        return null;
+    if (!Object.hasOwn(v, 'contentSnapshot') || !isString(v.contentSnapshot))
+        return null;
+    if (!Object.hasOwn(v, 'reason') || !isString(v.reason))
+        return null;
+    if (!Object.hasOwn(v, 'createdAt') || !isString(v.createdAt))
+        return null;
+    return {
+        id: v.id,
+        lang: v.lang,
+        contentHash: v.contentHash,
+        contentSnapshot: v.contentSnapshot,
+        reason: v.reason,
+        createdAt: v.createdAt,
+    };
+}
+export function validateIntentVersions(v) {
+    if (!isObject(v))
+        return null;
+    if (!Object.hasOwn(v, 'versions') || !Array.isArray(v.versions))
+        return null;
+    const versions = validateArray(v.versions, validateIntentVersionEntry);
+    if (versions === null)
+        return null;
+    return { versions };
+}