dsh-output-styles 0.3.2 → 0.4.1

package/src/renderers.ts

@@ -0,0 +1,264 @@
+/**
+ * The `output.render.*` protocol: a presenter registry that turns raw
+ * model-visible text into display text. A renderer is a pure function —
+ * `presenter(text, meta)` maps args to presentation data and never touches
+ * the DOM — matched by tool name and content type, ordered by priority.
+ * Every rendered result carries its original text alongside, so any consumer
+ * (this plugin's `/export`, third-party panels) can log both and keep the
+ * "model-visible ⟺ reconstructable" invariant.
+ *
+ * This module is dependency-free (no DOM, no node: imports, no DSH imports)
+ * so the protocol vocabulary itself is portable and unit-testable anywhere.
+ * @module dsh-output-styles/renderers
+ */
+
+/** Content-type vocabulary a renderer can match on. */
+export type ContentType = 'text' | 'markdown' | 'html'
+
+/** Match rule deciding whether a renderer applies to one render request. */
+export interface RendererMatch {
+  /** Tool names the renderer applies to ('*' = every tool); omitted = match all. */
+  readonly tool?: string | readonly string[]
+  /** Content types the renderer applies to; omitted = match all. */
+  readonly contentType?: ContentType | readonly ContentType[]
+}
+
+/** Facts a render request carries (structural; the DOM never reaches this layer). */
+export interface RenderContext {
+  /** The tool that produced the text, or '' for assistant/user prose. */
+  readonly tool: string
+  /** The declared content type of the text ('text' when unknown). */
+  readonly contentType: ContentType
+  /** The session the text belongs to (per-session rules match on it). */
+  readonly sessionId?: string
+  /** Session-scoped extras a presenter may read (workspace title etc.). */
+  readonly meta?: Readonly<Record<string, string>>
+}
+
+/** The renderer contract a third-party plugin registers. */
+export interface OutputRenderer {
+  /** Unique renderer id (kebab-case); the rule field and `/export --renderer` name it. */
+  readonly id: string
+  /** Human-readable name. */
+  readonly name: string
+  /** One sentence on what the presenter does. */
+  readonly description: string
+  /** Applicability rules; an empty array matches everything. */
+  readonly match: readonly RendererMatch[]
+  /** Higher priority wins; ties break by registration order (earlier first). */
+  readonly priority: number
+  /** Pure presentation function: args in, display data out. */
+  readonly presenter: (text: string, context: RenderContext) => string
+}
+
+/** The auditable render result: original and rendered travel together. */
+export interface RenderedText {
+  /** The original model-visible text (never mutated). */
+  readonly original: string
+  /** The presented text (equal to the original when nothing matched). */
+  readonly rendered: string
+  /** The renderer that applied, or undefined when no renderer matched. */
+  readonly rendererId?: string
+  /** Whether the presentation changed the text. */
+  readonly changed: boolean
+}
+
+/** One per-session/per-tool style rule from the configuration. */
+export interface StyleRule {
+  /** Match facts; an empty object matches everything. */
+  readonly match: {
+    /** Tool name or '*' (omitted = any tool). */
+    readonly tool?: string
+    /** Content type (omitted = any). */
+    readonly contentType?: ContentType
+    /** Exact session id (omitted = any session) — the per-session axis. */
+    readonly session?: string
+  }
+  /** Renderer id to apply (built-ins mirror the style names: concise, step-by-step). */
+  readonly style: string
+  /** Higher priority wins; ties break by rule order (earlier first). */
+  readonly priority: number
+}
+
+/** Registry handle returned by register(). */
+export type RendererDisposer = () => void
+
+/**
+ * Validates a renderer before registration: id grammar, name, description,
+ * match shape, priority, presenter function. Throws on the first violation
+ * (fail-loud — a bad renderer never sits in the registry).
+ * @param renderer - candidate renderer.
+ */
+export function validateRenderer(renderer: OutputRenderer): void {
+  if (typeof renderer !== 'object' || renderer === null) throw new Error('renderer must be an object')
+  if (typeof renderer.id !== 'string' || !/^[a-z0-9][a-z0-9-]*$/.test(renderer.id)) {
+    throw new Error(`invalid renderer id ${JSON.stringify(renderer.id)}: use kebab-case`)
+  }
+  if (typeof renderer.name !== 'string' || renderer.name === '') throw new Error('renderer name must be a non-empty string')
+  if (typeof renderer.description !== 'string' || renderer.description === '') throw new Error('renderer description must be a non-empty string')
+  if (!Array.isArray(renderer.match)) throw new Error('renderer match must be an array')
+  for (const match of renderer.match) {
+    if (match.tool !== undefined) {
+      const tools = Array.isArray(match.tool) ? match.tool : [match.tool]
+      if (!tools.every((item: unknown) => typeof item === 'string')) {
+        throw new Error('renderer match.tool must be a string or string array')
+      }
+    }
+    if (match.contentType !== undefined) {
+      const types = Array.isArray(match.contentType) ? match.contentType : [match.contentType]
+      if (!types.every((item: unknown) => typeof item === 'string')) {
+        throw new Error('renderer match.contentType must be a string or string array')
+      }
+    }
+  }
+  if (typeof renderer.priority !== 'number' || !Number.isFinite(renderer.priority)) {
+    throw new Error('renderer priority must be a finite number')
+  }
+  if (typeof renderer.presenter !== 'function') throw new Error('renderer presenter must be a function')
+}
+
+/** Match one rule fact (a string, a string list, or undefined=any) against a value. */
+function factMatches(fact: string | readonly string[] | undefined, value: string): boolean {
+  if (fact === undefined) return true
+  if (typeof fact === 'string') return fact === '*' || fact === value
+  return fact.includes('*') || fact.includes(value)
+}
+
+/** Whether a renderer matches a render request. */
+function rendererMatches(renderer: OutputRenderer, context: RenderContext): boolean {
+  if (renderer.match.length === 0) return true
+  return renderer.match.some(match =>
+    factMatches(match.tool, context.tool)
+    && factMatches(match.contentType, context.contentType))
+}
+
+/** Whether a configured rule matches a render request. */
+function ruleMatches(rule: StyleRule, context: RenderContext): boolean {
+  if (rule.match.tool !== undefined && rule.match.tool !== '*' && rule.match.tool !== context.tool) return false
+  if (rule.match.contentType !== undefined && rule.match.contentType !== context.contentType) return false
+  if (rule.match.session !== undefined && rule.match.session !== context.sessionId) return false
+  return true
+}
+
+/**
+ * The renderer registry: reversible registration, ordered resolution, and
+ * rule-driven rendering. Registration is a caller-owned effect (the runtime
+ * hands register()'s disposer to ctx.effect); the registry itself is pure
+ * state with no timers, listeners, or I/O.
+ */
+export class RendererRegistry {
+  private readonly renderers = new Map<string, { renderer: OutputRenderer; order: number }>()
+  private order = 0
+
+  /** Register a renderer; the disposer removes exactly this registration. */
+  register(renderer: OutputRenderer): RendererDisposer {
+    validateRenderer(renderer)
+    if (this.renderers.has(renderer.id)) {
+      throw new Error(`renderer ${JSON.stringify(renderer.id)} is already registered`)
+    }
+    const order = this.order++
+    this.renderers.set(renderer.id, { renderer, order })
+    return () => {
+      if (this.renderers.get(renderer.id)?.order === order) this.renderers.delete(renderer.id)
+    }
+  }
+
+  /** Every registered renderer, deterministic order (priority desc, registration asc). */
+  list(): OutputRenderer[] {
+    return [...this.renderers.values()]
+      .sort((a, b) => b.renderer.priority - a.renderer.priority || a.order - b.order)
+      .map(entry => entry.renderer)
+  }
+
+  /** Resolve the renderers that match a request, highest priority first. */
+  resolve(context: RenderContext): OutputRenderer[] {
+    return this.list().filter(renderer => rendererMatches(renderer, context))
+  }
+
+  /**
+   * Render text through the rule table, then the matching renderer pipeline:
+   * the first matching rule names a renderer (applied alone, it is explicit),
+   * otherwise every matching renderer applies in priority order (each sees the
+   * previous renderer's output — composition, not competition).
+   * @param text - the raw model-visible text.
+   * @param context - tool / content-type / session facts.
+   * @param rules - configured style rules, highest priority first.
+   * @returns the auditable result (original always preserved).
+   */
+  render(text: string, context: RenderContext, rules: readonly StyleRule[] = []): RenderedText {
+    const sortedRules = [...rules].sort((a, b) => b.priority - a.priority)
+    const hit = sortedRules.find(rule => ruleMatches(rule, context))
+    if (hit !== undefined) {
+      const renderer = this.renderers.get(hit.style)
+      if (renderer === undefined) {
+        throw new Error(`rule style ${JSON.stringify(hit.style)} names no registered renderer (available: ${this.list().map(item => item.id).join(', ') || 'none'})`)
+      }
+      const rendered = renderer.renderer.presenter(text, context)
+      return { original: text, rendered, rendererId: renderer.renderer.id, changed: rendered !== text }
+    }
+    let rendered = text
+    let rendererId: string | undefined
+    for (const renderer of this.resolve(context)) {
+      rendered = renderer.presenter(rendered, context)
+      rendererId = renderer.id
+    }
+    return { original: text, rendered, ...rendererId === undefined ? {} : { rendererId }, changed: rendered !== text }
+  }
+}
+
+/** Collapse whitespace runs and blank-line stacks; trim the ends. */
+function compact(text: string, maxLines: number, maxChars: number, marker: string): string {
+  const collapsed = text
+    .split(/\r?\n/)
+    .map(line => line.replace(/[ \t]+/g, ' ').trimEnd())
+    .reduce((lines: string[], line) => {
+      if (line === '' && lines[lines.length - 1] === '') return lines
+      lines.push(line)
+      return lines
+    }, [])
+    .join('\n')
+    .trim()
+  let out = maxLines > 0 && collapsed.split('\n').length > maxLines
+    ? collapsed.split('\n').slice(0, maxLines).join('\n') + marker
+    : collapsed
+  if (maxChars > 0 && out.length > maxChars) out = out.slice(0, maxChars) + marker
+  return out
+}
+
+/** Turn a list-shaped text into consistently numbered steps. */
+function enumerate(text: string): string {
+  const lines = text.split(/\r?\n/)
+  const items = lines.filter(line => /^\s*(?:[-*•]|\d+[.)])\s+/.test(line))
+  if (items.length === 0) return text
+  let counter = 0
+  return lines.map((line) => {
+    if (!/^\s*(?:[-*•]|\d+[.)])\s+/.test(line)) return line
+    counter += 1
+    return line.replace(/^\s*(?:[-*•]|\d+[.)])\s+/, `${counter}. `)
+  }).join('\n')
+}
+
+/**
+ * The built-in style renderers, mirroring the two headline styles: `concise`
+ * compacts whitespace under a line/char budget, `step-by-step` numbers list
+ * items consistently. Their ids double as `/style`-compatible names in the
+ * rule table.
+ */
+export const BUILTIN_RENDERERS: readonly OutputRenderer[] = [
+  {
+    id: 'concise',
+    name: 'Concise',
+    description: 'Compacts whitespace runs and blank lines, and caps the presented text at a budget with a truncation marker.',
+    match: [],
+    priority: 10,
+    presenter: text => compact(text, 40, 4000, '\n\n[truncated]'),
+  },
+  {
+    id: 'step-by-step',
+    name: 'Step-by-step',
+    description: 'Numbers list items (dashes, bullets, or digits) consistently from 1 so the presentation reads as ordered steps.',
+    match: [],
+    priority: 10,
+    presenter: text => enumerate(text),
+  },
+]

package/src/runtime.ts

@@ -24,6 +24,8 @@ import { installInvariant, PACKAGE_NAME, type InvariantFacts, type InvariantRegi
 import { loadStyleLibrary, truncateStyle, type OutputStyle } from './style-library.ts'
 import { applyStyleEvent, EMPTY_STYLE_STATE, parseStyleInput, STYLE_COMMAND, type StyleFoldState } from './style-command.ts'
 import { OUTPUT_STYLE_DOMAIN, STYLE_SOURCE, styleSelectionViewSchema, type StyleSelection, type StyleSelectionView } from './types.ts'
+import { BUILTIN_RENDERERS, RendererRegistry, type OutputRenderer, type RenderContext, type RenderedText, type StyleRule } from './renderers.ts'
+import { conversationLines, renderExport } from './export.ts'
 
 /** Bundled style-library directory (package `styles/`), the lowest-priority `stylesDir` entry. */
 export const DEFAULT_STYLES_DIR = fileURLToPath(new URL('../styles/', import.meta.url))
@@ -426,7 +428,10 @@ export async function apply(ctx: Context, config: Config): Promise<void> {
 
   // The invariant companion, registered from the main plugin so its checks
   // see the live library and domain. Activates only when an invariant
-  // registry is composed.
+  // registry is composed. The registry binds its internal effect to the
+  // service context and throws on a duplicate package name, so the returned
+  // disposer is the only unregistration path: hold it on this inject scope's
+  // fiber.
   ctx.inject(['invariants'], (invariantCtx) => {
     const registry = invariantCtx.get('invariants') as InvariantRegistry | undefined
     if (registry === undefined) return
@@ -434,6 +439,114 @@ export async function apply(ctx: Context, config: Config): Promise<void> {
       knownStyles: () => new Set(runtime.names),
       selectionFor: sessionId => runtime.selectionFor(sessionId),
     }
-    registry.register(PACKAGE_NAME, installInvariant(facts))
+    invariantCtx.effect(() => registry.register(PACKAGE_NAME, installInvariant(facts)), 'dsh-output-styles: invariant companion')
   })
+
+  // ── output.render.* protocol: the renderer registry service ───────────────
+  // Third-party plugins register presenters (id / match rules / pure
+  // presenter / priority) through `ctx.outputRenderers`; registration is a
+  // caller-owned effect (register() returns the disposer). The built-in
+  // concise/step-by-step renderers mirror the two headline styles. Rendering
+  // runs the `output.render/before` waterfall first — listeners transform the
+  // request and MUST call next() — then applies the rule table and matching
+  // renderers; every result keeps the original text beside the rendered one.
+  const renderers = new RendererRegistry()
+  for (const renderer of BUILTIN_RENDERERS) {
+    ctx.effect(() => renderers.register(renderer), `dsh-output-styles: renderer ${renderer.id}`)
+  }
+  let effectiveRules: readonly StyleRule[] = resolved.rules
+  const renderText = (text: string, context: RenderContext): Promise<RenderedText> =>
+    ctx.waterfall('output.render/before', { text, context }, async (request: { text: string; context: RenderContext }) =>
+      renderers.render(request.text, request.context, effectiveRules))
+  const renderService = {
+    register: (renderer: OutputRenderer) => renderers.register(renderer),
+    list: () => renderers.list(),
+    resolve: (context: RenderContext) => renderers.resolve(context),
+    renderText,
+  }
+  ctx.provide('outputRenderers', renderService)
+
+  // Per-session/per-tool rules over the settings seam: the `output-style-rules`
+  // namespace carries the rule table (composition `base` + user overrides);
+  // rules referencing an unknown renderer fail at write time, and rendering
+  // fails loudly at call time if a renderer left the registry.
+  installSettingsSection(
+    ctx,
+    settingsNamespace('output-style-rules'),
+    z.object({
+      rules: z.array(z.object({
+        match: z.object({
+          tool: z.string().required(false),
+          contentType: z.union([z.const('text'), z.const('markdown'), z.const('html')]).required(false),
+          session: z.string().required(false),
+        }).required(false),
+        style: z.string().min(1),
+        priority: z.number().required(false),
+      })).default([]),
+    }),
+    { rules: resolved.rules },
+    {
+      setSource: current => {
+        effectiveRules = current().rules.map(rule => ({ match: rule.match ?? {}, style: rule.style, priority: rule.priority ?? 0 }))
+      },
+      onChange: () => {},
+      validate: value => {
+        for (const rule of value.rules) {
+          if (rule.style === '' || /[^a-z0-9-]/.test(rule.style)) {
+            throw new Error(`dsh-output-styles: rule style ${JSON.stringify(rule.style)} must be a kebab-case renderer id`)
+          }
+        }
+      },
+    },
+  )
+
+  // The /export command: renders the current session's message surface to
+  // Markdown or sanitized HTML through the renderer pipeline. The document
+  // itself is the visible artifact; the original lines are the session log
+  // the export was projected from — rendered and original stay reconstructable.
+  if (resolved.enableExport) {
+    ctx.inject(['commands'], (commandCtx) => {
+      commandCtx.commands.register({
+        name: 'export',
+        description: 'Export this session as Markdown or HTML (renderer-aware)',
+        input: { hint: '[markdown|html] [--renderer=<id>]' },
+        handler: async ({ agent, rawInput }) => {
+          const input = parseExportInput(rawInput)
+          if (input.kind === 'error') {
+            return { kind: 'error', text: 'usage: /export [markdown|html] [--renderer=<id>]' }
+          }
+          const lines = conversationLines(agent.session.events)
+          const rules: StyleRule[] = input.renderer === undefined
+            ? [...effectiveRules]
+            : [{ match: {}, style: input.renderer, priority: 0 }]
+          const document = renderExport(renderers, lines, input.format, rules)
+          return { kind: 'success', text: document.text }
+        },
+      })
+    })
+  }
+}
+
+/** Parsed `/export` invocation. */
+type ExportInput = { kind: 'ok'; format: 'markdown' | 'html'; renderer?: string } | { kind: 'error' }
+
+/** Parse `/export [markdown|html] [--renderer=<id>]` from the raw command input. */
+export function parseExportInput(rawInput: unknown): ExportInput {
+  const raw = String(rawInput ?? '').trim()
+  const parts = raw === '' ? [] : raw.split(/\s+/)
+  let format: 'markdown' | 'html' = 'markdown'
+  let renderer: string | undefined
+  for (const part of parts) {
+    if (part === 'markdown' || part === 'html') {
+      format = part
+      continue
+    }
+    const match = /^--renderer=([a-z0-9][a-z0-9-]*)$/.exec(part)
+    if (match !== null) {
+      renderer = match[1]
+      continue
+    }
+    return { kind: 'error' }
+  }
+  return { kind: 'ok', format, ...renderer === undefined ? {} : { renderer } }
 }

package/src/types.ts

@@ -11,6 +11,7 @@
 import type { SessionId } from '@deepseek-ai/dsh-session'
 import { z as zod } from 'zod'
 import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain'
+import type { OutputRenderer, RenderContext, RenderedText } from './renderers.ts'
 
 /** The reserved switch target that removes a session's selection. */
 export const OFF = 'off'
@@ -84,3 +85,30 @@ declare module '@deepseek-ai/dsh-session-projection/types' {
     style: StyleSelectionView
   }
 }
+
+/** The `ctx.outputRenderers` service: the output.render.* renderer registry. */
+export interface OutputRenderersService {
+  /** Register a renderer (returns the disposer; caller owns it via ctx.effect). */
+  register(renderer: OutputRenderer): () => void
+  /** Every registered renderer, deterministic order (priority desc, registration asc). */
+  list(): OutputRenderer[]
+  /** Renderers matching a request, highest priority first. */
+  resolve(context: RenderContext): OutputRenderer[]
+  /** Render text through the `output.render/before` waterfall, then rules + matched renderers. */
+  renderText(text: string, context: RenderContext): Promise<RenderedText>
+}
+
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    /** The output.render.* renderer registry provided by dsh-output-styles. */
+    outputRenderers: OutputRenderersService
+  }
+  interface Events {
+    /**
+     * Pre-render waterfall: listeners receive `{ text, context }` and MUST
+     * call `next()` with their transformed request (or the unchanged one);
+     * returning without `next()` short-circuits the render pipeline.
+     */
+    'output.render/before'(request: { text: string; context: RenderContext }, next: (request: { text: string; context: RenderContext }) => Promise<RenderedText>): Promise<RenderedText>
+  }
+}

package/README.ja.md

@@ -1,202 +0,0 @@
-<div align="center">
-
-# 🎨 dsh-output-styles
-
-**DeepSeek Harness 向け Claude Code `outputStyles`** —— モデルの出力スタイルを実行時に、セッション単位で、永続的に切り替えます。
-
-[![License](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
-[![CI](https://github.com/PerryLink/dsh-output-styles/actions/workflows/ci.yml/badge.svg)](https://github.com/PerryLink/dsh-output-styles/actions/workflows/ci.yml)
-[![Node](https://img.shields.io/badge/node-%5E22.19%20%7C%7C%20%3E%3D24-brightgreen.svg)](#)
-[![DSH](https://img.shields.io/badge/deepseek--harness-0.1.0--rc.6-4d6bfe.svg)](#)
-[![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178c6.svg)](#)
-
-🌐 [English](README.md) · [中文](README.zh.md) · [日本語](README.ja.md) · [한국어](README.ko.md) · [Español](README.es.md)
-
-</div>
-
----
-
-`/style concise` —— これ以降の返信はすべて簡潔になります。`/style step-by-step` —— モデルが番号付きの手順で説明します。`/style off` —— プロジェクトのデフォルトに戻ります。セッションごとに 1 コマンド、再起動をまたいで保持され、agent loop には一切変更を加えません。
-
-## ✨ 機能
-
-| | |
-|---|---|
-| 🗂️ **スタイルライブラリ** | スタイルごとに 1 つの Markdown ファイル（`styles/*.md`）。frontmatter にメタデータ、本文がモデルへの指示です。`name` は既定でファイル名になり、空白を含めます（`Diagrams first`）。同梱の組み込みスタイルは 6 種で、Claude Code と同等の `proactive` と `learning` を含みます。 |
-| ⌨️ **`/style` コマンド** | 引数なしでスタイル一覧（説明付き）と現在の選択を表示。`/style <name>` で切り替え、`/style off` でプロジェクトのデフォルトを復元します。`/style` より後の残り全体がスタイル名です。 |
-| 💾 **セッション単位の永続化** | 選択は `output_style` ストレージドメインに sessionId をキーとして保持され、2 つのセッションが干渉することはなく、選択は再起動後も残ります。 |
-| 🧩 **システムプロンプト注入** | `systemPrompt.section()` の貢献（order 90）が、毎回の組み立てで現在のセッションのスタイル本文を注入します。本文は設定可能なバジェットで切り詰められます。 |
-| 🎭 **Claude Code `keep-coding-instructions`** | `keep-coding-instructions: false`（Claude Code と同じ既定）のスタイルはシステムプロンプト全体を置き換えます——ソフトウェアエンジニアリングから離れるスタイル向けです。 |
-| 📌 **強制スタイル** | Claude Code の `force-for-plugin`（エイリアス `force`）はセッションの選択を無視して無条件にスタイルを適用します。強制スタイルが 2 つあると読み込みに失敗します。 |
-| 🔁 **Claude Code 互換性** | `outputStyles` JSON コレクション（`{ name, description, prompt }`）を読み込みます。単一エントリまたは `settings.json` 形式の配列に対応し、解析不能なエントリは警告付きでスキップします。 |
-| 📚 **ディレクトリの階層化** | `stylesDir` はリストで、後方のディレクトリが前方のものを上書きします（同梱の `styles/` が最下層で、`includeBuiltins: false` で無効化）。 |
-| 🔄 **ホットリロード** | スタイルファイルの変更は再起動なしで反映されます（`watchStyles: false` で無効化）。 |
-| ⚙️ **settings とプロジェクトデフォルト** | 一度も選択していないセッションは、DSH settings の `output-style.style`、次いで `defaultStyle` にフォールバックします。 |
-| 🖱️ **Web ピッカー** | `dsh.client` エントリ（`dsh-output-styles/client`）が、ホストの `/style` コマンドを投影ベースのポップアップピッカーで装飾します。 |
-| 📊 **セッション投影** | Web UI 向けの `style` 投影（`{ options, currentValue }`）。セッションログ内で確定したコマンドから折りたたまれます。 |
-| 🧯 **失敗は明示、スキップはクリーンに** | 設定ミスは読み込み時に例外を投げます。不正なスタイルファイルは警告付きでスキップされ、プロファイルを壊すことはありません。 |
-| 🌐 **5 言語のドキュメント** | EN · 中文 · 日本語 · 한국어 · Español。 |
-
-## 🚀 クイックスタート
-
-```sh
-# 1. インストール——このパッケージは bundle レイヤーなので、1 コマンドで
-#    storage + storage-json + storage-domain + プラグイン行が構成されます：
-dsh plugin --profile <name> add dsh-output-styles
-
-# 2. 起動して切り替え
-dsh --profile <name>
-/style               # → output style off、その後にスタイルごとに 1 行
-/style concise       # → switched to concise
-/style Diagrams first  # → 空白を含む名前も使えます
-/style off           # → プロジェクトのデフォルトに戻る
-```
-
-このレイヤーは web プロファイルに対して冪等です（id 単位の挿入が同 id の行を置き換えます）。web プロファイルには `storage` があらかじめ含まれています。Web ピッカーを使うには、プロファイルにクライアント行を追加します：
-
-```yaml
-- id: output-styles-client
-  name: 'dsh-output-styles/client'
-```
-
-## 🎬 デモ
-
-```
-You > /style
-      output style off
-      concise — Terse, direct answers — minimal prose, no preamble. (Daily coding work, tool-heavy sessions, or when prompt length matters.)
-      explanatory — Educational answers with short "Insights" that teach as you work. (Learning a codebase, onboarding, …)
-      formal — Formal, precise prose with complete sentences and defined terms. (Reports, documentation, release notes, …)
-      learning — Collaborative learn-by-doing mode with short "Insights" and small hands-on steps for the user. (Pairing, onboarding, …)
-      proactive — Execute immediately, assume reasonable defaults, and prefer action over planning. (Routine multi-step work, …)
-      step-by-step — Numbered reasoning steps with explicit intermediate results. (Debugging, design decisions, …)
-
-You > /style concise
-      switched to concise
-
-You > 一文だけで自己紹介してください。
-AI  > 私は DeepSeek Harness プラグインプラットフォーム上で動作する、deepseek-v4-pro モデルベースの AI コーディングエージェントです。
-```
-
-## 🧠 仕組み
-
-```mermaid
-flowchart LR
-    U[/style concise と入力] --> C[コマンドレジストリ]
-    C -->|command/run を記録| L[(セッションログ)]
-    C -->|put {style, source}| D[(output_style ドメイン)]
-    D --> R[OutputStyleRuntime]
-    R -->|毎回の組み立てで本文を注入| S[systemPrompt セクション order 90]
-    S --> M[モデルリクエスト]
-    M -->|完全なシステムプロンプト| H[request/header を記録]
-```
-
-モデルが見るものはすべてセッションログから再構築できます——新しいセッションイベント型も agent-loop の変更も不要です。スタイル名は `command/run` から、注入された正確なテキストは `request/header` から得られ、出所マーカー `{ kind: 'plugin', plugin: 'dsh-output-styles' }` はドメインレコードに残ります。スタイルはメイン会話のみに適用され、サブエージェントのセッションは独自のプロンプトを保持します（Claude Code と一致）。
-
-## ⚙️ 設定
-
-すべての調整項目は検証付きの Schemastery `Config` フィールドです（不正な値は読み込みに失敗します）：
-
-| フィールド | 既定 | 意味 |
-|---|---|---|
-| `stylesDir` | `[]` | スタイルライブラリのディレクトリ。cwd を基準に解決され、後方のエントリが前方のものを上書きします。`[]` = 同梱の `styles/` のみ。裸の文字列は単一ディレクトリのリストとみなされます。 |
-| `maxStyleChars` | `4000` | スタイル本文のバジェット（コードポイント、≥ 1）。長い本文はマーカー付きで切り詰められます。 |
-| `defaultStyle` | `''` | 一度も選択していないセッション（かつ settings の既定もない）向けのスタイル。`''` = スタイルなし。 |
-| `compatJson` | `true` | Claude Code `outputStyles` の JSON エントリ（単一オブジェクトまたは配列）を読み込みます。 |
-| `sectionOrder` | `90` | 注入セクションの順序（0 = persona、100–199 = ツールガイダンス）。 |
-| `truncationMarker` | `"\n\n[style truncated]"` | 切り詰め位置に付加されるマーカー。 |
-| `includeBuiltins` | `true` | パッケージ同梱の `styles/` を最優先度の低いレイヤーとして含めます。 |
-| `watchStyles` | `true` | スタイルファイルがディスク上で変更されたときにライブラリを再読み込みします。 |
-
-## 📚 スタイルライブラリ
-
-<details>
-<summary><code>styles/concise.md</code></summary>
-
-```markdown
----
-name: concise
-description: Terse, direct answers — minimal prose, no preamble.
-whenToUse: Daily coding work, tool-heavy sessions, or when prompt length matters.
-keep-coding-instructions: true
----
-
-You are in the concise output style for this conversation.
-- Lead with the direct answer; skip preamble, restatements, and filler.
-- 回答语言跟随用户语言：中文提问用中文回答，英文提问用英文回答。
-```
-
-</details>
-
-frontmatter フィールド：
-
-| フィールド | 既定 | 意味 |
-|---|---|---|
-| `name` | ファイル名 | 切り替え対象。英字、数字、空白、ハイフン（先頭・末尾の空白は不可。`off` は予約済み）。 |
-| `description` | —（必須） | 一覧とピッカーに表示される 1 文。 |
-| `whenToUse` | — | 一覧に追記される任意の利用ガイダンス。 |
-| `keep-coding-instructions` | `false` | `true` のときハーネスのプロンプト（アイデンティティ、persona、ツールガイダンス）を保持し、`false` のとき完全に置き換えます（Claude Code のセマンティクス）。 |
-| `force-for-plugin` | `false` | Claude Code 公式フィールド：セッションの選択を無視して無条件に適用します。`force` はエイリアスで、設定できるのは最大 1 つのスタイルです。 |
-
-<details>
-<summary>Claude Code <code>outputStyles</code> JSON（<code>compatJson: true</code>）</summary>
-
-```json
-{ "name": "explain", "description": "Explain like a teacher.", "prompt": "Teach in small steps." }
-```
-
-エントリは Claude Code が書き込むとおりに `keep-coding-instructions` と `force-for-plugin` を受け付けます。レガシーの `settings.json` 配列（`[{ … }, { … }]`）はそのまま読み込まれ、不正なエントリは警告付きでスキップされます。
-
-</details>
-
-## ⌨️ コマンドリファレンス
-
-| 入力 | 結果 |
-|---|---|
-| `/style` | 現在の選択 + スタイルごとに 1 行（name — description）を一覧表示 |
-| `/style concise` | 切り替え（永続書き込み）、`switched to concise` |
-| `/style Diagrams first` | 複数語の名前は残り全体が対象 |
-| `/style off` | プロジェクトのデフォルトを復元（settings の既定、次いで `defaultStyle`） |
-| `/style nope` | `error: unknown output style "nope" (available: …)` |
-
-## 🖱️ Web ピッカー
-
-`dsh.client` エントリは、ホストの `/style` コマンドの引数なし呼び出しをポップアップピッカーで装飾します：「off」行 + ライブラリのスタイルごとに 1 行（`description · whenToUse`）で、アクティブな行がマークされます。選択するとコマンド Remote を通じて `/style <name>` が送信されるため、どの切り替えもホストの永続的なコマンドライフサイクルを経由し、`style` 投影が唯一の表示事実であり続けます。ピッカーの文言は Web UI が同梱する `zh`/`en` の言語ペアに従います。
-
-## 🔍 競合チェック
-
-開発前に DSH エコシステムを調査しました（2026-08 スナップショット）：[topic:dsh-plugin](https://github.com/topics/dsh-plugin) 配下に `style`/`output-style` のリポジトリはなく、4 つの主要な [awesome リスト](https://github.com/awesome-dsh-plugin/awesome-dsh-plugin) に output-style カテゴリはなく、[dsh-hub カタログ](https://github.com/omdsh-dev/dsh-hub-workshop) にもエントリはありません。最も近い隣接プロジェクト——[dsh-soul-md](https://github.com/Scorp1o117/dsh-soul-md)（persona）と [dsh-claude-marketplace](https://github.com/ben7am1n/dsh-claude-marketplace)（出力スタイルは明示的に v0.2+ へ先送り）——は隣接していて、競合はしません。
-
-## 🆚 Claude Code との違い
-
-| | Claude Code | dsh-output-styles |
-|---|---|---|
-| スタイルファイル | ユーザー/プロジェクト/マネージド階層の `.claude/output-styles` | `stylesDir` ディレクトリ + 同梱の `styles/`。後方のディレクトリが優先 |
-| カスタムスタイル | Markdown、frontmatter `name`/`description`/`keep-coding-instructions`/`force-for-plugin` | 同じフィールド（`force-for-plugin` をそのまま受け付け、`force` はエイリアス）+ `whenToUse` |
-| レガシー JSON | `settings.json` 内の `outputStyles` 配列 | そのまま読み込み（`compatJson: true`） |
-| 反映タイミング | `/clear` 後または新しいセッション | 即時——システムプロンプトはリクエストごとに再構築 |
-| サブエージェント | スタイルは適用されない | 同じ——サブエージェントのセッションは独自のプロンプトを保持 |
-| 切り替え | `/config` メニューまたは `outputStyle` 設定（`/output-style` コマンドは v2.1.91 で削除） | `/style` コマンド + Web ピッカー + settings `output-style.style` |
-
-## 🧪 開発
-
-```sh
-pnpm install
-pnpm run typecheck   # 両方の tsc プロジェクト
-pnpm test            # vitest — 93 テスト
-pnpm run verify      # typecheck + テスト + 自己完結チェック（prepublishOnly ゲート）
-pnpm run build       # lib/ 成果物（ホスト + クライアント bundle）
-pnpm pack            # dsh plugin add 用の tarball
-```
-
-リリース：`package.json` のバージョンと一致する接尾辞を持つ `v*` タグを push すると Publish ワークフローが起動します——完全検証の後に npm へ公開（provenance 付き）。あらゆる `npm publish` も `prepublishOnly` 経由で `verify` ゲートを通過します。
-
-構成は [omdsh-dev/plugin-template](https://github.com/omdsh-dev/plugin-template) に従います：`src/index.ts`（プラグインメタデータ）、`src/config.ts`（スキーマ）、`src/runtime.ts`（ランタイムサービス + アクティベーション）、`src/invariant.ts`（不変条件）、`src/client/`（Web ピッカー）、`styles/`（組み込みスタイル）。
-
-## 📄 ライセンス
-
-[Apache-2.0](LICENSE) © 2026 dsh-output-styles contributors
-
----
-
-<sub>Topics: `dsh` · `dsh-plugin` · `deepseek-harness` · `output-styles` · `claude-code`</sub>