@lmzhen/dsh-evolution-ui 0.0.0 → 0.32.1

package/lib/types/panels/history/client/document.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The READING face: one version rendered as a document, and the rendered diff.
+ *
+ * This file is the only place that decides how a document reads (G4). The tool face (`chrome.ts`)
+ * picks versions and acts on them; here the rules are the reader's, and they follow the positioning
+ * ruling of §14.0: a document is read, not scanned — one measure, page-like spacing, no inner scroll
+ * (W18/W20/W21/W22). Nothing here is a control except the source/rendered choice, which belongs to
+ * the reader rather than to the panel's actions.
+ *
+ * The text arrives already prepared: the host strips the frontmatter block through core's
+ * `displayBodyOf`, because a browser half cannot import core. The RENDERED DIFF keeps the whole text
+ * on purpose — a diff is about what CHANGED, and a metadata change is a change.
+ *
+ * It degrades rather than blanking: when the platform's renderer cannot be reached, the exact text is
+ * shown instead, and the reader can still read the version.
+ * @module @lmzhen/dsh-evolution-ui/panels/history/client
+ */
+import { type ReactNode } from 'react';
+import type { VersionBodyRow, VersionDiffRow } from './api.ts';
+import type { Copy } from './chrome.ts';
+import { type MarkdownWords } from './markdown.ts';
+/** What one expanded diff holds: the change, still loading, or a refusal. */
+export type DiffState = {
+    kind: 'loading';
+} | {
+    kind: 'ready';
+    diff: VersionDiffRow;
+} | {
+    kind: 'failed';
+    message: string;
+};
+/** What one expanded preview holds. */
+export type BodyState = {
+    kind: 'loading';
+} | {
+    kind: 'ready';
+    body: VersionBodyRow;
+} | {
+    kind: 'failed';
+    message: string;
+};
+/** What the reading face needs: the dictionary seat, plus the two words the platform renderer takes. */
+export interface DocumentFace extends Copy {
+    readonly markdownWords: MarkdownWords;
+}
+/**
+ * One version read as a document: the platform renderer when it is there, plain text when it is not.
+ *
+ * The document is the page, not a card inside it: no border, no surface of its own and no inner
+ * scroll, so the pane's own scrollbar is the only one a reader meets (W20/W21). A body the host
+ * bounded says how much it is not showing, with both numbers (W23).
+ * @param props - the face and the body state to draw.
+ * @returns the element.
+ */
+export declare function PreviewBody(props: {
+    face: DocumentFace;
+    body: BodyState;
+}): ReactNode;
+/**
+ * The expanded body of one row: the diff, a loading line, or the refusal.
+ *
+ * The source/rendered choice is LOCAL to this view: which row is open is the panel's business, but
+ * how one open diff is displayed is not, so the state does not climb into the parent.
+ * @param props - the face and the diff state to draw.
+ * @returns the element.
+ */
+export declare function DiffBody(props: {
+    face: DocumentFace;
+    diff: DiffState;
+}): ReactNode;
+//# sourceMappingURL=document.d.ts.map

package/lib/types/panels/history/client/guards.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Is this a non-null, non-array object (what JSON calls an object)?
+ * @param value - the value to test.
+ * @returns whether it is a plain object.
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Read a value as a record, or undefined when it is not one.
+ * @param value - the value to read.
+ * @returns the value typed as a record, or undefined.
+ */
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+//# sourceMappingURL=guards.d.ts.map

package/lib/types/panels/history/client/ids.d.ts

@@ -0,0 +1,3 @@
+export declare const PANEL_ID = "skill-history";
+export declare const PANEL_ORDER = 35;
+//# sourceMappingURL=ids.d.ts.map

package/lib/types/panels/history/client/index.d.ts

@@ -0,0 +1,11 @@
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+/** Required client services: the slot registry and the locale seat. */
+export declare const inject: string[];
+/** Row order inside the global panel list (beside the platform's own rows). */
+export declare const PANEL_ORDER = 35;
+/**
+ * Register the locale namespace, the panel row and the panel body.
+ * @param ctx - the client cordis context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/panels/history/client/markdown.d.ts

@@ -0,0 +1,56 @@
+/** The three localized words the platform renderer needs; the face owns them. */
+export interface MarkdownWords {
+    readonly copy: string;
+    readonly copied: string;
+    /** The heading of the generated footnote section. */
+    readonly footnotes: string;
+}
+/** Copy-button labels forwarded to fenced code blocks. */
+interface MarkdownCodeLabels {
+    copyLabel: string;
+    copiedLabel: string;
+}
+/** Localized Markdown chrome: every field the platform component requires. */
+interface MarkdownLabels {
+    code: MarkdownCodeLabels;
+    footnotes: string;
+}
+/** What the renderer reads; the streaming and mention knobs are not used by this panel. */
+interface MarkdownTextProps {
+    text: string;
+    labels: MarkdownLabels;
+}
+/** The component as the module table hands it over. */
+type MarkdownTextComponent = (props: MarkdownTextProps) => unknown;
+/** One render attempt: the element, or the news that this deployment has no renderer. */
+export type MarkdownRender = {
+    readonly ok: true;
+    readonly node: unknown;
+} | {
+    readonly ok: false;
+};
+/**
+ * The renderer a module row carries, when it carries one.
+ *
+ * A React component type is NOT always a function: the platform's own `MarkdownText` is
+ * `memo(function MarkdownText …)`, and `memo` returns an OBJECT. A `typeof === 'function'` test
+ * therefore rejected the real renderer and silently degraded every view to its source — exactly
+ * what 0.14.0 shipped (measured on the installed panel 2026-09-28: `[预览]` and the rendered diff
+ * both fell back). The accepted domain is React's element-type domain: a function, or a non-null
+ * object it can mount. `tests/markdown.client.spec.ts` pins all four cases.
+ * @param row - what the client module table handed over.
+ * @returns the component, or undefined when the row carries none.
+ */
+export declare function rendererOf(row: {
+    MarkdownText?: unknown;
+}): MarkdownTextComponent | undefined;
+/**
+ * Render one Markdown document to an element tree.
+ * @param text - the Markdown source (already bounded by the caller).
+ * @param words - the localized Markdown chrome.
+ * @returns the element, or `{ ok: false }` when the platform renderer is not reachable (the caller
+ *   then keeps its own source view: a missing renderer degrades the view, never the panel).
+ */
+export declare function renderMarkdown(text: string, words: MarkdownWords): MarkdownRender;
+export {};
+//# sourceMappingURL=markdown.d.ts.map

package/lib/types/panels/history/client/messages.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Panel copy, in a zh/en dictionary registered through the platform’s locale seat.
+ *
+ * Client copy is locale-owned: the entry label, the group headings, the actions, the version facts
+ * (action words, relative time, deltas) and the status lines all resolve here, and the panel carries
+ * no literal string of its own. Facts come from the host; only the WORDS live here.
+ * @module @lmzhen/dsh-evolution-ui/panels/history/client
+ */
+/** The locale namespace this bundle registers. */
+export declare const NS = "evolution-skill-history";
+/** Chinese dictionary. */
+export declare const zh: Record<string, string>;
+/** English dictionary: the same keys, or the panel falls back to the key itself. */
+export declare const en: Record<string, string>;
+/**
+ * One message without the locale seat (the fallback path, and what a spec reads).
+ * @param language - which dictionary to read.
+ * @param key - the message key.
+ * @returns the copy, or the key itself when neither dictionary carries it.
+ */
+export declare function message(key: string, language?: 'zh' | 'en'): string;
+/**
+ * Fill one TEMPLATE’s `{n}` slots. The seat resolves the key, this fills it, so the panel needs
+ * only the seat plus this rule and never learns which language it is rendering.
+ * @param template - the copy, with `{slot}` placeholders.
+ * @param values - the substitutions, keyed by the slot name inside the braces.
+ * @returns the filled copy.
+ */
+export declare function fill(template: string, values: Record<string, string | number>): string;
+//# sourceMappingURL=messages.d.ts.map

package/lib/types/panels/history/client/styles.d.ts

@@ -0,0 +1,5 @@
+/** Tag id that makes the injection idempotent. */
+export declare const CSS_TAG_ID = "@lmzhen/dsh-evolution-ui/panel.css";
+/** The stylesheet the panel injects once. */
+export declare const CSS: string;
+//# sourceMappingURL=styles.d.ts.map

package/lib/types/panels/history/host.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Host half of the skill-history surface: it mounts the six routes the sidebar panel reads and
+ * writes, and it owns nothing else.
+ *
+ * W6/G4: the carrier is the platform's Host connection data plane. `registerHostRoutes` waits on the
+ * `connection` service (it may apply after this row), registers via one owner effect and captures the
+ * DecisionAudit there; the old webServer + loopback fence path is gone.
+ *
+ * The version FACTS come from evolution-core (which artifact a version holds, how the body chain and
+ * the support-file chain split) and the only write is the curator's undo, so this row carries no state
+ * of its own: unloading it removes the routes and leaves the feature's data untouched.
+ * @module @lmzhen/dsh-evolution-ui/panels/history
+ */
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "evolution-skill-history";
+/** No declared service: a headless profile must not leave a pending row, and the curator is resolved
+ * per request; `connection` is waited on inside registerHostRoutes, not demanded here. */
+export declare const inject: string[];
+/**
+ * Mount the routes as ONE owner effect (disposers run on unload and on HMR). A profile whose host has
+ * no connection service simply never runs the callback — inert, never pending.
+ * @param ctx - the host context; the connection and curator arrive through it.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=host.d.ts.map

package/lib/types/panels/history/routes.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The skill-history HTTP surface: six exact Fetch routes over the curator's read/write seam (five
+ * reads plus the one write).
+ *
+ * W6/G4: the carrier is the platform's Host connection data plane — the fence, browser auth and
+ * owner-only admission are applied by the platform BEFORE `fetch(request)` runs, so this module has
+ * no 403/401 branch. The wire envelope the browser half reads is unchanged.
+ *
+ * Layering: this module maps a route to a USE CASE and does nothing else. "Which artifact does this
+ * version hold" and "how do the two chains split" live in evolution-core; the only write is
+ * curator.undo. The panel never writes the skill tree itself.
+ * @module @lmzhen/dsh-evolution-ui/panels/history/routes
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ConnectionFetchRouteLike, DecisionAudit } from '@lmzhen/dsh-evolution-core/http-routes';
+/** Route paths: the ONE declaration lives in core (W1); the client constants are generated from it. */
+export declare const SKILL_HISTORY_ROUTES: {
+    readonly skills: "/api/dsh-evolution/skill-history/skills";
+    readonly versions: "/api/dsh-evolution/skill-history/versions";
+    readonly diff: "/api/dsh-evolution/skill-history/versions/diff";
+    readonly body: "/api/dsh-evolution/skill-history/versions/body";
+    readonly undo: "/api/dsh-evolution/skill-history/undo";
+    readonly health: "/api/dsh-evolution/skill-history/health";
+};
+/**
+ * How much of one version's body the read route hands back. A bound on the ANSWER, not on what the
+ * deployment may store: a long skill arrives as its head plus `truncated`, so the reader is told.
+ */
+export declare const MAX_BODY_CHARS = 20000;
+/** The curator surface the routes read: history() and the library listing, undo() as the only write. */
+export type CuratorFace = Pick<Context['evolutionCurator'], 'history' | 'undo' | 'undoUnit' | 'skills'>;
+/**
+ * What the handlers resolve PER REQUEST.
+ *
+ * The curator is looked up late, not captured: a profile that mounts these routes before the curator
+ * (or without it) answers the family's own E-302 sentence instead of throwing, which is how every
+ * other optional-service consumer in this family behaves.
+ */
+export interface RouteServices {
+    readonly getCurator: () => CuratorFace | undefined;
+}
+/**
+ * Build the six routes over the curator seam.
+ * @param services - the host services the handlers read.
+ * @param _audit - the registration audit (read routes record nothing; undo's decision stays the
+ *   curator's own — W6 keeps the ledger to the approval surface).
+ * @returns the route list for `registerHostRoutes`.
+ */
+export declare function makeSkillHistoryRoutes(services: RouteServices, _audit: DecisionAudit): ConnectionFetchRouteLike[];
+//# sourceMappingURL=routes.d.ts.map

package/lib/types/panels/history/unit-undoable.d.ts

@@ -0,0 +1,18 @@
+/**
+ * G3b: undoability is a property of the UNIT, not of one entry.
+ *
+ * Every entry of a unit shares the same live body, so "is this undoable" must answer the same for all
+ * of them; computing it per entry made the body row say `false` (already current) while a support row
+ * of the SAME transaction said `true` — two entrances to one unit in one panel.
+ *
+ * Entries without a unit id keep the per-entry answer (they are their own singleton unit).
+ */
+import { type SkillVersion } from '@lmzhen/dsh-evolution-core';
+/** @param members - every entry that shares the unit (content and support chains together).
+ * @param liveHash - hash of the live body, or null when the skill is not readable.
+ * @returns one flag per unit id; unknown ids fall back to the per-entry rule. */
+export declare function unitUndoableFlags(members: readonly SkillVersion[], liveHash: string | null): Map<string, boolean>;
+/** @param entry - the entry being rendered. @param flags - the unit flags from {@link unitUndoableFlags}.
+ * @param liveHash - hash of the live body. @returns the row's `undoable` value. */
+export declare function undoableFor(entry: SkillVersion, flags: Map<string, boolean>, liveHash: string | null): boolean | undefined;
+//# sourceMappingURL=unit-undoable.d.ts.map

package/lib/types/panels/settings/DiagnosticsCard.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The diagnostics card (W7 S7): the settings face of the SAME DiagnosticsView the CLI and the
+ * `/api/dsh-evolution/diagnostics` route answer.
+ *
+ * Read-only by construction: it fetches once on mount and only refetches on an explicit Refresh; a
+ * failed read renders the shared FailureBlock with the command-face fallback. The client owns no
+ * key list and no status vocabulary: it renders the host view's frozen runtime rows and leads with
+ * a plain-language summary. The view's documentation facts are a CLI/JSON concern and are
+ * deliberately NOT rendered here (0.27.2 real-machine feedback: a settings page is not a spec
+ * sheet; the runtime window is the whole reading).
+ * @module @lmzhen/dsh-evolution-ui/panels/settings/client/DiagnosticsCard
+ */
+import { type ReactNode } from 'react';
+import type { DiagnosticsApi } from './diagnostics-state.ts';
+import type { FallbackHint } from '@lmzhen/dsh-evolution-client-kit/generated/contracts';
+import type { MessageKey } from './messages.ts';
+/** Injected face: the copy seat, the one host call, and this surface's command fallback. */
+export interface DiagnosticsCardFace {
+    t: (key: MessageKey, values?: Readonly<Record<string, string | number>>) => string;
+    api: DiagnosticsApi;
+    fallback?: FallbackHint | undefined;
+}
+/**
+ * Render the card.
+ * @param props - the copy seat, the host call and the command fallback.
+ * @returns the card.
+ */
+export declare function DiagnosticsCard(props: DiagnosticsCardFace): ReactNode;
+//# sourceMappingURL=DiagnosticsCard.d.ts.map

package/lib/types/panels/settings/ParamCard.d.ts

@@ -0,0 +1,107 @@
+/**
+ * One namespace's parameter card.
+ *
+ * Structural local types on purpose: this package is distributed outside the
+ * platform repository and a value import of another plugin is forbidden, so the
+ * settings scope and its snapshot are declared by the shape the renderer hands
+ * over (\`getSnapshot\`/\`subscribe\`, status/value/user/writable).
+ *
+ * header (namespace title, change count, chevron), then one block per field —
+ * header (namespace title, change count, chevron), then one block per field —
+ * label with its unit and source chip, a control HOLDING THE CURRENT VALUE, the
+ * Chinese hint — and one 放弃修改/保存 pair at the card's foot. The control is
+ * typed from the registry (\`control\`), so booleans are switches, enums are
+ * selects and numbers are numeric inputs with the unit shown beside the label.
+ */
+import { type ReactNode } from 'react';
+import type { ClientParamField } from './generated-params.ts';
+import { type MessageKey } from './messages.ts';
+import type { ParamSectionSnapshot, ParamSectionSource, SettingsPathOpLike } from './seam.ts';
+/**
+ * Injected face: plain data and callbacks, plus the hook seat.
+ *
+ * The `hooks` compartment belongs to the shell, not to the component: the
+ * renderer binds its entries to `use<Name>` props and omits `hooks` from what
+ * the component receives. A card that reads `props.hooks` therefore reads a prop
+ * that never exists.
+ */
+export interface ParamCardFace {
+    namespace: string;
+    fields: readonly ClientParamField[];
+    t: (key: MessageKey, values?: Readonly<Record<string, string | number>>) => string;
+    /** ONE call per save, carrying every dirty field as one op list (T5-01/A56). The returned boolean IS
+     * the Host's verdict (contract C2/G5): `true` = accepted, `false` = refused after its recovery read. */
+    mutateOnce: (ops: readonly SettingsParamOp[]) => Promise<boolean>;
+    clear: (field: string) => Promise<boolean>;
+    hooks: {
+        paramSection: ParamSectionSource;
+    };
+}
+/**
+ * Props the renderer binds for one card: the inject face minus its hook compartment,
+ * plus the seats bound from it. Spelled the way the shell derives it, so reaching for
+ * `props.hooks` fails the type check instead of failing at runtime.
+ */
+export type ParamCardProps = Omit<ParamCardFace, 'hooks'> & {
+    /** Bound from \`hooks.paramSection\` by the renderer. */
+    readonly useParamSection: <T>(selector: (state: ParamSectionSnapshot) => T) => T;
+};
+/** The op list a save hands to the seat — the seam's own shape, never a second vocabulary. */
+export type SettingsParamOp = SettingsPathOpLike;
+/**
+ * The NAMESPACE-RELATIVE key of one registry field.
+ *
+ * The E3 registry writes family ids in canonical form (`evolution-approval.pendingTtlMs`),
+ * while the platform settings seat speaks a namespace's own field keys (`pendingTtlMs`) —
+ * its snapshot user layer, its base and its op paths are all relative to the namespace. Sending
+ * the canonical id as an op path makes the Host refuse the write
+ * ("Config field evolution-approval.pendingTtlMs is not volatile", measured 2026-10-19), so the
+ * card translates once, here, and every read/write goes through it.
+ * @param namespace - the settings namespace (Loader row id) the card writes.
+ * @param field - one generated field.
+ * @returns the field's key inside that namespace.
+ */
+export declare function fieldKeyOf(namespace: string, field: ClientParamField): string;
+/**
+ * U-4: whether one field's CURRENT text is a value the Host can take. The controls constrain their own
+ * domains (a number input sanitizes, a select only offers listed values), so the reachable case is a
+ * value the registry no longer lists — carried in the user layer and re-staged by any other edit.
+ * @param field - the generated field.
+ * @param text - the text the control holds right now.
+ * @param peer - U-4: the text the row this field declares `atLeast` against currently holds (absent
+ * when the field declares no relation, or when that row is not on this card).
+ * @returns the message key explaining the refusal, or null when the value is acceptable.
+ */
+export declare function invalidReason(field: ClientParamField, text: string, peer?: string): MessageKey | null;
+/**
+ * Render one namespace's card.
+ * @param props - the card data, its callbacks, and the bound section hook.
+ * @returns the card.
+ */
+/** Props of the shared body: the card's own data plus the row state it renders. */
+export interface ParamCardViewProps {
+    namespace: string;
+    fields: readonly ClientParamField[];
+    t: (key: MessageKey, values?: Readonly<Record<string, string | number>>) => string;
+    /** ONE call per save, carrying every dirty field as one op list (T5-01/A56). */
+    mutateOnce: (ops: readonly SettingsParamOp[]) => Promise<boolean>;
+    /** Ask the scope to drop one override; resolves when the scope answered, not when it landed. */
+    clear: (field: string) => Promise<boolean>;
+    /** The current row state, from whichever source owns it (the bound hook or the page). */
+    snapshot: ParamSectionSnapshot;
+}
+/**
+ * Render one row's card body from a supplied snapshot.
+ * @param props - the card data, its callbacks, and the row state to render.
+ * @returns the card.
+ */
+export declare function ParamCardView(props: ParamCardViewProps): ReactNode;
+/**
+ * The card as our own section renders it: the row state comes from the hook seat the
+ * renderer binds out of the inject face's `hooks` compartment (components never hold a
+ * subscription of their own).
+ * @param props - the card data, its callbacks, and the bound row hook.
+ * @returns the card.
+ */
+export declare function ParamCard(props: ParamCardProps): ReactNode;
+//# sourceMappingURL=ParamCard.d.ts.map

package/lib/types/panels/settings/PendingCard.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The "writes awaiting approval" card: the staged write window, with the two decisions on each row.
+ *
+ * It is a card in the SAME section and wears the SAME shell as the parameter cards (header with title,
+ * count and chevron; body of field blocks; a button row per block), so nothing here invents a second
+ * visual language. Two things differ on purpose: the data comes from the host's approval routes rather
+ * than the settings transport, and its three states are distinct — "reading", "nothing staged" and "the
+ * read failed" each say so in their own words (E7: merging the first two is what made an empty panel
+ * look like lost data).
+ *
+ * Every decision re-reads the window instead of predicting the outcome: the host owns the state, and a
+ * refusal is shown with the host's own sentence.
+ * @module @lmzhen/dsh-evolution-ui/panels/settings/client/PendingCard
+ */
+import { type ReactNode } from 'react';
+import type { FallbackHint } from '@lmzhen/dsh-evolution-client-kit/generated/contracts';
+import type { ApprovalApi } from './api.ts';
+import type { MessageKey } from './messages.ts';
+/** Injected face: the copy seat and the host calls. No hook compartment — this card keeps its own state. */
+export interface PendingCardFace {
+    t: (key: MessageKey, values?: Readonly<Record<string, string | number>>) => string;
+    api: ApprovalApi;
+    /**
+     * U-6 (registry `approvalConfirm`): read PER RENDER, like the entry's own seat probe — a value
+     * captured once would pin the gate for the life of the fiber. Absent ⇒ the shipped default `auto`.
+     */
+    confirmMode?: () => 'auto' | 'ask' | 'timeout';
+    /** G5/W7 S4: the command-face fallback rendered with an unreachable/unauthenticated failure. */
+    fallback?: FallbackHint | undefined;
+}
+/**
+ * U-6: the registry's gate word, read out of a section's user layer. ONE definition, exported so the
+ * mapping itself is judgeable: the entry does the wiring, this does the reading. Anything that is not
+ * one of the two explicit words falls back to the shipped default (`auto`) — a document written by a
+ * future version must not silently turn the confirmation ON, and a typo must not turn it off. The
+ * independent review flagged that this reader had no case at all (P2-11).
+ */
+export declare function confirmModeFrom(user: unknown): 'auto' | 'ask' | 'timeout';
+/**
+ * Render the pending window.
+ * @param props - the copy seat and the host calls.
+ * @returns the card.
+ */
+export declare function PendingCard(props: PendingCardFace): ReactNode;
+//# sourceMappingURL=PendingCard.d.ts.map

package/lib/types/panels/settings/RowConfigCard.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The Plugins page's per-row configuration entry for a family row.
+ *
+ * The page owns the settings subscription — it re-renders the entry — and passes the row's
+ * form in, so this component renders the SAME card body as our own section, fed by the
+ * page's state instead of the bound hook and therefore holding no subscription of its own.
+ * `summary` answers the page's one-line slot: a row's description fallback, which stays
+ * empty until the row actually overrides something, exactly as the page expects.
+ * @module @lmzhen/dsh-evolution-ui/panels/settings/client
+ */
+import { type ReactNode } from 'react';
+import type { ClientParamField } from './generated-params.ts';
+import type { MessageKey } from './messages.ts';
+import type { RowConfigViewProps } from './seam.ts';
+/** The inject face every row registration carries (the page supplies `view` and `form`). */
+export interface RowConfigFace {
+    /** The row's entry id, for the card title. */
+    namespace: string;
+    fields: readonly ClientParamField[];
+    t: (key: MessageKey, values?: Readonly<Record<string, string | number>>) => string;
+}
+/** Props one row entry is rendered with: the page's seat plus this row's own face. */
+export type RowConfigCardProps = RowConfigViewProps & RowConfigFace;
+/**
+ * Render one row's configuration entry.
+ * @param props - the page's view/form seat plus this row's face.
+ * @returns the entry; `summary` renders nothing for an untouched row (the page then keeps the row's own description).
+ */
+export declare function RowConfigCard(props: RowConfigCardProps): ReactNode;
+//# sourceMappingURL=RowConfigCard.d.ts.map

package/lib/types/panels/settings/SettingsSection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The section shell: title, one-line explanation, then one card per namespace — with the staged-write
+ * window's card ahead of them all, because it is the only card here that waits on a decision.
+ *
+ * This is the shape the platform's own settings sections use — a heading plus the
+ * child slots it declared in its registration. The cards themselves are separate
+ * registrations keyed by namespace, so a namespace the Host does not serve simply
+ * renders nothing and a deployment that drops this row loses the whole section.
+ * @module @lmzhen/dsh-evolution-ui/panels/settings/client
+ */
+import { type ReactNode } from 'react';
+import { type SectionFace } from './seam.ts';
+/**
+ * Render the section.
+ * @param face - the shell's inject face: translator and child-slot renderer.
+ * @returns the section element.
+ */
+export declare function SettingsSection(face: SectionFace): ReactNode;
+//# sourceMappingURL=SettingsSection.d.ts.map

package/lib/types/panels/settings/api.d.ts

@@ -0,0 +1,64 @@
+import { type RouteAnswer } from '@lmzhen/dsh-evolution-client-kit/generated/route-client';
+/** One staged write, as the pending route hands it over (never the staged args). */
+export interface PendingRow {
+    readonly id: string;
+    readonly kind: 'memory' | 'skill' | 'capability';
+    readonly summary: string;
+    readonly createdAt: string;
+    /** How long ago it was staged, in the family's `{unit, n}` closed vocabulary. */
+    readonly age: {
+        readonly unit: string;
+        readonly n: number;
+    };
+    readonly status: 'pending' | 'executing' | 'approved' | 'rejected';
+    readonly claimedBy?: string | undefined;
+}
+/** One windowed hunk of a previewed change: the region the write would touch. */
+export interface PreviewHunk {
+    readonly path: string;
+    readonly oldText: string;
+    readonly newText: string;
+}
+/**
+ * What a staged write WOULD store. `available: false` carries the host's reason — plenty of records have
+ * no bytes worth showing, and the reader is owed that sentence rather than an empty diff.
+ */
+export type PreviewAnswer = {
+    readonly available: true;
+    readonly path: string;
+    readonly linesAdded: number;
+    readonly linesRemoved: number;
+    readonly hunks: readonly PreviewHunk[];
+    readonly truncated: boolean;
+} | {
+    readonly available: false;
+    readonly reason: string;
+};
+/** What one call answered: the generated four-state RouteAnswer (no local failure vocabulary). */
+export type ApprovalAnswer<T> = RouteAnswer<T>;
+/**
+ * Which window the pending route is asked for. The host route has always taken `?status=` (the CLI
+ * asks for both); this half asked for neither, so a record stuck in `executing` — an approve that
+ * died between the claim and the decision, or another process running it — was invisible in the GUI
+ * while `/evolution pending` and doctor both listed it (T4-05/A47). `PendingRow.status` even declared
+ * the member, so the type face expected data the data face could not reach.
+ */
+export type PendingWindow = 'pending' | 'executing';
+/** How this bundle reaches the host. Injectable so a spec drives it without a server. */
+export interface ApprovalApi {
+    /** The staged writes in one window; `pending` when the caller does not say. */
+    pending: (status?: PendingWindow) => Promise<ApprovalAnswer<readonly PendingRow[]>>;
+    /** Ask the host to replay one staged write. */
+    approve: (id: string) => Promise<ApprovalAnswer<unknown>>;
+    /** Close one staged write without replaying it. */
+    reject: (id: string) => Promise<ApprovalAnswer<unknown>>;
+    /** What that staged write would store, resolved by the host without running it. */
+    preview: (id: string) => Promise<ApprovalAnswer<PreviewAnswer>>;
+}
+/**
+ * Build the approval face over one fetch implementation.
+ * @param doFetch - the fetch to use (the platform's global in the browser, a fake in a spec).
+ * @returns the three calls the pending card makes.
+ */
+export declare function createApprovalApi(doFetch: typeof fetch): ApprovalApi;
+//# sourceMappingURL=api.d.ts.map

package/lib/types/panels/settings/diagnostics-state.d.ts

@@ -0,0 +1,28 @@
+import { type RouteAnswer } from '@lmzhen/dsh-evolution-client-kit/generated/route-client';
+import type { DiagnosticsView } from '@lmzhen/dsh-evolution-client-kit/generated/contracts';
+/** What the card renders: the view, or the classified failure that kept it from arriving. */
+export type DiagnosticsState = {
+    readonly phase: 'loading';
+} | {
+    readonly phase: 'ready';
+    readonly view: DiagnosticsView;
+} | {
+    readonly phase: 'failed';
+    readonly failure: import('@lmzhen/dsh-evolution-client-kit/generated/route-client').RouteFailure;
+};
+/** The one call the card makes. */
+export interface DiagnosticsApi {
+    view(): Promise<RouteAnswer<DiagnosticsView>>;
+}
+/**
+ * Build the diagnostics face over one fetch implementation.
+ * @param doFetch - the browser fetch, or a spec stub.
+ */
+export declare function createDiagnosticsApi(doFetch?: typeof fetch): DiagnosticsApi;
+/**
+ * Read the view once and map it onto the card's four states (loading is the caller's initial value).
+ * @param doFetch - the fetch to use.
+ * @returns ready with the view, or failed with the classified failure.
+ */
+export declare function loadDiagnostics(doFetch?: typeof fetch): Promise<DiagnosticsState>;
+//# sourceMappingURL=diagnostics-state.d.ts.map

package/lib/types/panels/settings/generated-about.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GENERATED by packages/scripts/gen-about.mjs — do not edit.
+ *
+ * The version comes from the repository package.json and the purpose from this package own
+ * description, so the settings surface can state both without a hand-written copy.
+ */
+/** The family version this surface belongs to. */
+export declare const FAMILY_VERSION = "0.32.1";
+/** What this surface is for, in one line. */
+export declare const PACKAGE_PURPOSE = "Web UI umbrella for the evolution family: settings, merge, skill history and skill health panels";
+//# sourceMappingURL=generated-about.d.ts.map