kiokuko-dsh 0.2.36 → 0.2.38

package/docs/dsh-plugin.md

@@ -53,7 +53,7 @@ requires an explicit resume and a new generation. Old results cannot complete
 or modify that new generation. Model changes transfer the same task to the
 verified primary continuation; CLI resume rereads its persisted state.
 
-Jev/Laya interpretations are advisory. If they are unavailable or abstain, the
+Jev/Laya/OpenAI interpretations are advisory. If they are unavailable or abstain, the
 host records an unresolved decision and accepts a validated main-model
 interpretation or an explicit operation. The original request and authority
 checks remain in force. The CLI displays this SQLite snapshot and committed
@@ -220,6 +220,20 @@ Released v0/v1/v2/v3 history readers are bundled privately into the npm artifact
 
 ## Remove
 
+| Target | After `dsh plugin remove` | How to remove it |
+|---|---|---|
+| DSH rows (`kiokuko-dsh` / `kiokuko-models`) | Removed; the stock export row is restored | No further action |
+| Deployed Skills under `~/.agents/skills` | Remain | `setup-dsh.mjs --remove` |
+| DSH block in `AGENTS.md` | Remains | `setup-dsh.mjs --remove` |
+| `kiokuko-models.json` | Remains | Remove manually only when the saved provider definitions are no longer needed |
+| Kiokuko database and `.agenticreplay/runs` | Remain intentionally | Do not remove them as part of plugin removal |
+
+Disable individual rows when temporarily turning Kiokuko off. Disabling the whole
+bundle also removes the provider referenced by `agent-default-model`, leaving its
+default-model binding unresolved. `patchReload: "live"` has no reader in the
+current DSH and must not be treated as evidence that a profile change took effect
+immediately.
+
 ```bash
 dsh plugin --profile web remove kiokuko-dsh
 ```
@@ -268,19 +282,24 @@ block in the startup directory’s `AGENTS.md`, as described below.
 ## Bundled standard Skills: canonical source and refresh
 
 The repository's `skills/<name>/` directories are the single canonical source
-for the eight standard Skills and for the bundled Japanese output Skill.
+for the 16 standard Skills and for the separately bundled Japanese output and
+Lisp Skills.
 `src/dsh/standard-skills.ts` resolves them relative to the built module
 (`dist/dsh/` → `../../skills/<name>`), and `src/dsh/standard-skill-integrity.ts`
 refuses to load a tree that breaks the manifest: exactly one management marker
 per file, frontmatter `name` equal to the manifest name with a non-empty
 description and no `disable-model-invocation`, every local Markdown link
-resolvable inside its own Skill, and exactly 8 Skills with 27 Markdown files and
-19 reference files.
+resolvable inside its own Skill, and exactly 16 standard Skills with 42 Markdown
+files and 26 reference files.
 
-The Japanese output Skill is an additional ninth Skill. Its directory is
+The Japanese output Skill and Lisp Skill bring the package inventory to 18 Skill
+directories. The Japanese output directory is
 `japanese-translation-for-oss-models/`; its frontmatter/provider name is
-`natural-japanese-output`. Both names refer to the same Skill. Deployment includes
-all nine Skills and 28 Markdown files, including the 19 references.
+`natural-japanese-output`. Both names refer to the same Skill. Setup deploys the
+16 standard Skills plus
+Japanese output: 17 directories and 43 files, including the 26 references. Lisp
+is supplied through the DSH Skill provider and is not installed globally by this
+setup path.
 
 `veteran-programmer-skill` checks workflow completeness before and after changes
 spanning setup, delivery, persisted state or runtime handoffs. SOUL and the code
@@ -300,8 +319,9 @@ alone does not establish remaining input budget or model quality.
 The enabled plugin runs setup on every load, before registering its DSH surfaces:
 
 1. Validate the bundled Skills and preflight the deployment targets.
-2. Synchronize all eight managed Skill directories to the process user's
-   `~/.agents/skills/`, creating missing files and replacing stale managed files.
+2. Synchronize all 16 standard Skill directories and the Japanese output Skill
+   to the process user's `~/.agents/skills/`, creating missing files and replacing
+   stale managed files.
 3. Replace the existing `<!-- BEGIN KIOKUKO-DSH MANAGED BLOCK -->` through
    `<!-- END KIOKUKO-DSH MANAGED BLOCK -->` section of the startup directory's
    `AGENTS.md` with the DSH contract. Preserve all text outside those markers.
@@ -356,6 +376,9 @@ npm run build
 node scripts/setup-dsh.mjs --cwd /absolute/path/to/project --check
 node scripts/setup-dsh.mjs --cwd /absolute/path/to/project
 node scripts/setup-dsh.mjs --cwd /absolute/path/to/project --check
+# Explicitly remove byte-identical deployed copies and the DSH AGENTS.md block.
+node scripts/setup-dsh.mjs --cwd /absolute/path/to/project --remove
+node scripts/setup-dsh.mjs --cwd /absolute/path/to/project --remove --check
 ```
 
 The same `scripts/setup-dsh.mjs` ships in the installed package. Use the **actual
@@ -374,8 +397,8 @@ runtime user. Check the reported paths: a successful source build or bundled
 parity check alone does not prove that another process's deployed files match.
 
 `node scripts/verify-standard-skills.mjs` remains a source/bundle integrity check
-for the eight standard Skills (27 files, 19 references). Use `setup-dsh.mjs --check`
-for the complete nine-Skill deployment **and** project instruction check.
+for the 16 standard Skills (42 files, 26 references). Use `setup-dsh.mjs --check`
+for the complete 17-directory, 43-file deployment **and** project instruction check.
 
 ## STORE contract and permissions
 
@@ -402,9 +425,14 @@ Runtime effects are explicit:
 - optional GitHub or embedding credentials are supplied by the user and are
   never bundled or persisted by the plugin.
 
-`prepare` runs only `npm run build`. Git installs need build approval in the
-consuming profile; use the repository-scoped rule in [Install](#install) so
-ordinary updates do not require another commit-specific permission.
+`prepare` runs `node scripts/prepare-build.mjs`, which normally builds through
+the invoking package manager. Only `CI=true` together with
+`KIOKUKO_CI_DEFER_PREPARE=1` defers this package's duplicate build to the selected
+verifier's clean build; dependency lifecycle scripts remain enabled. See
+[CI build ownership](verification.md#consolidated-duplicate-invocations).
+Git installs still need build approval in the consuming profile; use the
+repository-scoped rule in [Install](#install) so ordinary updates do not require
+another commit-specific permission.
 
 The npm tarball already contains `dist/`, so its normal install path does not
 depend on a consumer-side build permission.

package/docs/getting-started.ja.md

@@ -3,6 +3,8 @@
 `kiokuko-dsh`はDeepSeek Harness向けPluginです。公開パッケージが提供する
 のは`./dsh` Plugin entrypointだけです。導入、session、lifecycleはDSHが所有します。
 
+補助判定でOpenAIを使う場合は、[OpenAI Decisionsの設定](../README.ja.md#openai-decisions-setup)でAPIキーの保存先とWeb profileとの違いを確認してください。主モデルのChatGPT/Codex OAuthとは別です。手順は現行ソースの対応を示し、公開済みnpmの `latest` に含まれることを保証しません。
+
 ## インストール
 
 公式 DeepSeek Harness の現在のソースと Node.js 24.16.0 以上を使用します。DSH の版名による固定判定はせず、実際のホスト API と解決したソース revision に対する隔離試験で互換性を確認します。[検証範囲](current-upstream-compatibility-report.md)を参照してください。

package/docs/getting-started.md

@@ -3,6 +3,8 @@
 `kiokuko-dsh` is a DeepSeek Harness plugin. The published package contains the
 `./dsh` plugin entrypoint. DSH owns installation, sessions, and lifecycle.
 
+Before choosing OpenAI for auxiliary decisions, follow the [OpenAI Decisions setup](../README.md#openai-decisions-setup) for API-key storage and the Web-profile path distinction. Main-model ChatGPT/Codex OAuth is separate. The guide describes current source support, not a guarantee about the published npm `latest`.
+
 ## Install
 
 Use current official DeepSeek Harness and Node.js 24.16.0 or newer. Compatibility is checked against actual host APIs and the resolved upstream source revision, not a fixed DSH release label. See [verified scope](current-upstream-compatibility-report.md).

package/docs/lisp.md

@@ -282,6 +282,45 @@ remain available when the AI loop is stopped:
 /kioku-lisp recover
 ```
 
+The default `status` view shows counts and up to three unresolved Lisp operations
+and three unresolved external operations, each with its exact `diagnostics` command.
+Successful operation IDs stay in `/kioku-lisp status --json`; ordinary status does
+not print the full history. Reading either view never starts or recovers a worker.
+
+An owned file proposal rejected by the host before dispatch is `NOT_APPLIED`,
+not an unknown mutation. The Lisp generation and its definitions remain usable;
+the host's preparation and permission checks still apply to any later attempt.
+An error after dispatch, even with identical text, remains `UNKNOWN`.
+
+`RECONCILIATION_REQUIRED` means external effects still lack a verifiable receipt.
+Inspect `/kioku-lisp diagnostics OPERATION_ID` and the original host evidence.
+A SIGTERM or job settlement message alone is not proof that the process and its
+resources stopped. No interrupted command is automatically retried.
+
+Restarting Lisp cannot clear an unknown external operation, and neither can
+`recover` or `abandon`. While one remains, every later effect is refused. After
+inspecting the original receipt, end only the operations you have confirmed are
+harmless; the recorded text is the human evidence, not an observed result:
+
+```text
+/kioku-lisp abandon-managed OPERATION_ID
+/kioku-lisp recover
+```
+
+`abandon-managed` accepts only `unknown` operations, requires the inspection
+evidence, and records no success or failure outcome. It never re-executes the
+command and never reverts an effect, so operations whose effects you cannot
+verify must stay open until you resolve them yourself. The Lisp control beside
+the session input offers the same action for the listed operations, and a scope
+containing an abandoned operation cannot later be used as protocol test evidence.
+
+A host that supplies versioned Bash termination receipts can reconcile an exact
+original native child as `cancelled-confirmed` after observing its managed range
+empty. The plugin checks the child/root call, agent, session and exact dispatched
+working directory. The Lisp timeout or cancellation stays an error, and prior
+command effects remain. Older hosts, missing receipts and mismatched identities
+remain unresolved; text, SIGTERM and job settlement cannot substitute for proof.
+
 In ordinary development conversations, `recover` starts a fresh worker after a
 timeout, output limit or Stop, including between turns. It needs no task setup;
 old turn permissions remain expired, and definitions/heap values are discarded.
@@ -430,9 +469,10 @@ The legacy lisp.approvalMode ask/auto configuration and profile commands remain
 Use kioku_read/write/edit/remove/exec/result for observed work. Host receipts distinguish actual process outcome, source-bound verification and saving status. Lisp/model passed fields are advisory. Saving can be retried without repeating development effects; after restart an interrupted process remains unknown. See [owned execution](owned-execution.md).
 <!-- /kiokuko:runtime -->
 
-Pinned DSH stores this setting in the native `kiokuko-lisp` namespace, keyed by
-the host-owned profile identity. Current DSH exposes `lisp.approvalMode` through
-the native `kiokuko-dsh` configuration form and saves its profile patch. This
+Pinned DSH stores the approval setting in the native `kiokuko-lisp` namespace, keyed by
+the host-owned profile identity. Current DSH exposes `lisp.approvalMode`, the
+`startupDefaults` pair and `typedDecisions.provider` together through the native
+`kiokuko-dsh` configuration form, and saves the profile patch. This
 compatibility difference does not change the controls or scope. No separate
 preference file or database migration is used.
 
@@ -530,6 +570,7 @@ Clean installation and platform status: [code intelligence setup](code-intellige
 
 ## Coding task choice and recovery
 
-For a new coding task, `coding_workflow` first defines and displays the Goal, implementation items and observable conditions. The host then asks whether to use Lisp. Configuration alone never implies yes; an explicit manual session ON is reused as the selected route. Closing the question leaves it pending and `coding_workflow next` reopens the same question. Explicit continuation after a host restart restores the task choice; a new task or material scope change asks again. A saved yes followed by startup failure remains a visible blocker; recover the runtime or explicitly change the task route with `/kioku-lisp disable`. No uses ordinary tools and still requires fresh item checks followed by a final user-entry Goal check. Lisp evaluation success alone is insufficient: bind `task_completion` and collect actual host process evidence. See [coding workflow](coding-workflow.md).
+For a new coding task, `coding_workflow` first defines and displays the Goal, implementation items and observable conditions. The host then asks whether to use Lisp. Configuration alone never implies yes; an explicit manual session ON is reused as the selected route.
+`startupDefaults.lisp` (default `ask`) only preselects the Lisp answer on the task-startup card, which stays editable; a saved answer still wins. The default never enables the module or satisfies a yes: a missing runtime or failed startup remains the same recoverable blocker. Closing the question leaves it pending and `coding_workflow next` reopens the same question. Explicit continuation after a host restart restores the task choice; a new task or material scope change asks again. A saved yes followed by startup failure remains a visible blocker; recover the runtime or explicitly change the task route with `/kioku-lisp disable`. No uses ordinary tools and still requires fresh item checks followed by a final user-entry Goal check. Lisp evaluation success alone is insufficient: bind `task_completion` and collect actual host process evidence. See [coding workflow](coding-workflow.md).
 
 Live opt-in condition/restart recovery: see [bounded recovery](lisp-recovery.md).

package/docs/model-selection.ja.md

@@ -14,7 +14,7 @@ DSHの権限判定、必要な検証を維持し、役小角の契約・WorkUnit
 
 Webプロファイルでは [Kiokuko Models](kiokuko-models.md) から接続を設定できます。DSH本体のModelsで設定する必要はありません。登録したモデルは、通常会話・Enno・Deepでネイティブ接続と併用できます。
 
-通常版・modular coreとも `modelAutoMode.mode: off` が既定です。同じDSHプロファイルでKiokuko Modelsまたはdsh-codexからCodexを認証し、JevかLayaの判定を準備したうえで、まず `observe` で選択案を確認します。
+通常版・modular coreとも `modelAutoMode.mode: off` が既定です。同じDSHプロファイルでKiokuko Modelsまたはdsh-codexからCodexを認証し、Jev・Laya・[OpenAI](typed-decisions.md#openai-credentials)のいずれかの判定を準備したうえで、まず `observe` で選択案を確認します。
 
 ```yaml
 modelAutoMode:
@@ -34,7 +34,7 @@ modelAutoMode:
 
 初期候補は `gpt-6-luna` の low・medium・high と `gpt-6-sol` の high です。`modelAutoMode.routes` には最大4件、`id`（`luna-low`、`luna-medium`、`luna-high`、`sol-high`）と `binding`（`provider`、`model`、`reasoningEffort`）を指定できます。IDは経路のラベルなので、登録済みのAstraなども正確なbindingで割り当てられます。候補はCodex由来とResponses方式を確認でき、現在のモデル一覧、文脈容量・入力形式・推論強度、要求設定の検証、token meterを通った接続に限定します。ネイティブの `openai-codex` とKiokuko所有のCodex接続が対象です。名前だけを似せた接続やOpenAI API接続は対象外です。有効なbindingが2件未満なら判定しません。
 
-新しい受付済みの通常タスクでは、現在の依頼文、タスク種別、添付の種類、経路IDと判定基準を選択中のJevかLayaへ送ります。この判定のために添付の内容、全履歴、リポジトリ全体は送信しません。Choice 1問の結果をrunに保存し、継続では同じ経路を使います。再起動時に判定結果が不明なら再送せず元のモデルを維持します。`observe`、棄権、probe失敗、metadata不足、非対応effort、timeout、入力超過でも元のモデルを維持します。取消、セッション同一性の不一致、保存の整合性エラーでは要求を止めます。認証・利用枠・モデル利用不可によるdispatch失敗を別モデルへ自動再送しません。
+新しい受付済みの通常タスクでは、現在の依頼文、タスク種別、添付の種類、経路IDと判定基準を選択中のJev・Laya・OpenAIへ送ります。この判定のために添付の内容、全履歴、リポジトリ全体は送信しません。Choice 1問の結果をrunに保存し、継続では同じ経路を使います。再起動時に判定結果が不明なら再送せず元のモデルを維持します。`observe`、棄権、probe失敗、metadata不足、非対応effort、timeout、入力超過でも元のモデルを維持します。取消、セッション同一性の不一致、保存の整合性エラーでは要求を止めます。認証・利用枠・モデル利用不可によるdispatch失敗を別モデルへ自動再送しません。
 
 状態表示では、設定・準備状態・選択案・適用したbindingと、nativeの `request/header` で確認した実モデルを区別します。初期候補は判定基準であり、品質・時間・利用枠の改善を保証しません。Enno、Deep、子、雑談、回答の再検討、保護されたLisp実行は既存の経路を使います。実装失敗後の自動昇格は初期版に含めません。
 

package/docs/model-selection.md

@@ -15,7 +15,7 @@ plan approval or automatic Enno continuation.
 
 In Web profiles, [Kiokuko Models](kiokuko-models.md) manages connections without requiring DSH's Models settings. Its registered models are available to ordinary chat, Enno and Deep alongside native connections.
 
-`modelAutoMode` is off by default in both the full plugin and modular core. To try it, authenticate Codex through Kiokuko Models or dsh-codex in the same DSH profile, configure a Jev or Laya typed-decision backend, then use `observe` before enabling automatic routing:
+`modelAutoMode` is off by default in both the full plugin and modular core. To try it, authenticate Codex through Kiokuko Models or dsh-codex in the same DSH profile, configure a Jev, Laya or [OpenAI typed-decision backend](typed-decisions.md#openai-credentials), then use `observe` before enabling automatic routing:
 
 ```yaml
 modelAutoMode:
@@ -35,7 +35,7 @@ The command changes only the current native session. `on` also clears its manual
 
 The initial preset offers `gpt-6-luna` at low, medium and high effort, plus `gpt-6-sol` at high effort. Up to four exact route bindings can be configured under `modelAutoMode.routes`; each has an `id` from `luna-low`, `luna-medium`, `luna-high`, `sol-high`, and a `binding` with `provider`, `model`, and `reasoningEffort`. These are route labels, so a registered Astra or other GPT model may be assigned explicitly. No new model ID is guessed or substituted. A candidate must have a validated Codex origin and Responses protocol, live model context and modality metadata, supported efforts, call-config validation and token meter. Both native `openai-codex` and Kiokuko-owned Codex routes qualify; an arbitrary provider name or OpenAI API connection does not. Fewer than two valid bindings skips classification.
 
-For a new admitted normal task, Kiokuko sends the current task text, task type, attachment kinds, route IDs and rubric to the selected Jev or Laya backend. It does not send attachment bytes, full history or repository contents for this classification. One Choice result selects a route or abstains. The route is stored against the exact run and reused for continuations; an unknown in-flight decision after restart is retained without another classifier call. `observe` records a proposal but keeps the current model. A failed probe, missing metadata, unsupported effort, timeout, oversized input or abstention also keeps the current model. Cancellation, stale session identity and storage integrity failures stop the request. Dispatch authentication, quota and unavailable-model errors remain ordinary failures; no alternate model is retried automatically.
+For a new admitted normal task, Kiokuko sends the current task text, task type, attachment kinds, route IDs and rubric to the selected Jev, Laya or OpenAI backend. It does not send attachment bytes, full history or repository contents for this classification. One Choice result selects a route or abstains. The route is stored against the exact run and reused for continuations; an unknown in-flight decision after restart is retained without another classifier call. `observe` records a proposal but keeps the current model. A failed probe, missing metadata, unsupported effort, timeout, oversized input or abstention also keeps the current model. Cancellation, stale session identity and storage integrity failures stop the request. Dispatch authentication, quota and unavailable-model errors remain ordinary failures; no alternate model is retried automatically.
 
 The status distinguishes the configured mode, readiness, proposal and selected binding from the model observed in a native `request/header`. The initial preset is a rubric, not a claim that it improves quality, elapsed time or subscription usage. Enno, Deep, children, chat, review continuation and protected Lisp execution retain their existing owners. Automatic escalation after a failed implementation pass is not enabled.
 

package/docs/store-evidence.md

@@ -17,6 +17,12 @@ permissions, and disposable-profile result independently.
 | npm lifecycle | `prepare: npm run build` |
 | Automatic size policy | intentionally exceeded; manual `user-reviewed` track |
 
+This table records the **0.1.3 review snapshot**, including its original lifecycle
+command; it is not the current package's release evidence. Current source uses
+`prepare: node scripts/prepare-build.mjs` with normal builds and an explicit CI-only
+deferral. See [current lifecycle and permissions](../PERMISSIONS.md#installation-lifecycle)
+and [CI build ownership](verification.md#consolidated-duplicate-invocations).
+
 The Commit field is filled only after the user commits and pushes the verified
 working tree. The catalog must point to that full immutable Commit, not a branch
 name or moving tag.

package/docs/typed-decisions.md

@@ -23,11 +23,16 @@ excerpted or rewritten, and classification grants no execution permission.
 The common API also accepts explicit `noul` (yes probability) and `score`
 (ordered rubric) questions. Their validated answers have `status: "measured"`;
 they grant no permission. The existing Choice request and answer shapes remain
-valid. TypeSafe can evaluate all three question types in one batch. Nimble and
+valid. TypeSafe and OpenAI can evaluate all three question types in one batch. Nimble and
 Laya accept Choice only and return `DECISION_UNSUPPORTED` before inference for
 other kinds. The separate Lisp `kioku.typesafe:evaluate` API retains its own
 wire contract.
 
+The configured provider (`typedDecisions.provider`, default `typesafe`) is the default
+for new requests whenever this project has no saved selection. `/kioku-decisions use`
+still saves an explicit project selection, which the configured default never
+overwrites; `use default` returns to it.
+
 Switch backends in DSH without a restart:
 
 ```text
@@ -49,6 +54,59 @@ base configuration. A stale host cannot overwrite a selection saved by another
 host; restart it to load the latest choice. Changing the base configuration uses
 that configuration's selection, with the YAML provider as the default.
 
+<a id="openai-credentials"></a>
+## OpenAI credentials
+
+Jev remains the default; OpenAI, local Laya and Nimble are alternatives. OpenAI uses the official [Decisions API](https://developers.openai.com/api/docs/guides/decisions), `POST /v1/decisions`, with `gpt-6-luna` as this checkout's default decision model. This is separate from the main chat model: ChatGPT/Codex OAuth login does not supply `OPENAI_API_KEY`, and a TypeSafe/Jev key cannot replace it.
+
+These instructions describe the current source. They do not assert that the published npm `latest` already includes OpenAI support. If `use openai` is unavailable, check the installed build's command support first.
+
+1. Create an API key for your OpenAI API project and add it to the credential store used by the running DSH. With the standard `credentials-local` provider, choose the path as follows:
+
+   | Configuration | Credential file |
+   |---|---|
+   | Default harness home | `~/.dsh/.credentials.yaml` |
+   | Custom `DSH_HOME` | `$DSH_HOME/.credentials.yaml` |
+   | Explicit `credentials.path` (the provider's `config.path`) | The configured path, overriding the home default |
+
+   `--profile web` keeps profile packages and patches under `$DSH_HOME/profiles/web`; it does **not** by itself move credentials there. A profile can override `credentials.path`, or its launcher can use another `DSH_HOME`. Use that effective file, not a guessed `profiles/web/.credentials.yaml`.
+
+2. In an existing file, add only `OPENAI_API_KEY` under `refs` and preserve all other `refs` and `records`. This is a minimal **new-file example**, with a nonfunctional placeholder:
+
+   ```yaml
+   version: 1
+   refs:
+     OPENAI_API_KEY: "OPENAI_API_KEY_EXAMPLE_ONLY"
+   records: {}
+   ```
+
+   Replace the placeholder privately with your key. On macOS/Linux, protect the actual file; for the default path:
+
+   ```sh
+   chmod 600 "$HOME/.dsh/.credentials.yaml"
+   ```
+
+   Use your configured path instead when it differs. The default `watch: true` reloads valid file edits automatically for subsequent requests; restarting DSH is unnecessary. Do not paste keys into chat, screenshots or Git.
+
+3. In DSH's command input, select OpenAI and inspect the result:
+
+   ```text
+   /kioku-decisions use openai
+   /kioku-decisions status
+   ```
+
+   `use openai` makes a real API probe, which may incur usage charges. Only a successful probe and save persist the choice for this project and new requests; failure or cancellation keeps the prior choice. Existing requests keep their binding. `status` makes no inference call. Optional `/kioku-decisions probe` makes another real probe.
+
+The standard provider resolves **saved file > launch environment > project `.env` > harness-home `.env`**. Environment variables still work when the credentials service is present, unless a saved value overrides them. For an environment-only setup, export the key **before** launching DSH from that shell:
+
+```sh
+export OPENAI_API_KEY='OPENAI_API_KEY_EXAMPLE_ONLY'
+```
+
+This is a placeholder, not a usable key. An export in another shell after DSH has started does not update its launch snapshot; use the watched file to update an already running instance. Keep credential-bearing `.env` files out of Git.
+
+## Provider configuration
+
 Configure `typedDecisions` on the full plugin or modular core:
 
 OpenAI uses the distinct official [Decisions API](https://developers.openai.com/api/docs/guides/decisions),
@@ -56,21 +114,43 @@ OpenAI uses the distinct official [Decisions API](https://developers.openai.com/
 It maps Choice, Noul (predicate) and Score to the native API and validates ordered
 named answers, distributions, rubric levels and individual refusals. The default
 model is `gpt-6-luna`; probability ≥ 0.9 and margin ≥ 0.2 are required for Choice.
-Set `OPENAI_API_KEY` through DSH credentials (or the environment when no credentials
-service exists). TypeSafe credentials are never substituted. No redirects,
+Kiokuko resolves `OPENAI_API_KEY` through `ctx.credentials.resolve` when the service
+exists; the standard local provider includes the launch environment and `.env`
+fallbacks described [above](#openai-credentials). Only a composition without that
+service uses Kiokuko's direct `process.env` fallback. A different credential
+provider may have different resolution rules. TypeSafe credentials are never substituted. No redirects,
 automatic retries, or provider fallback are added. `use openai` probes before
 persisting; missing credentials, failed probes and cancellation leave selection unchanged.
 Existing Jev/Laya stored configuration digests retain their original shape.
 Current token records retain input/output totals; cached-token breakdown is not recorded.
 
+To select OpenAI in the plugin or core configuration instead of a project command:
+
+```yaml
+typedDecisions:
+  mode: auto
+  provider: openai
+  openai:
+    model: gpt-6-luna
+    timeoutMs: 5000
+```
+
+Keep keys in the credential store, not in `typedDecisions`. A configured provider
+is not evidence of a successful API call; use the command probe to verify access.
+
 The normal startup card offers the four decision/Lisp ON/OFF combinations and Cancel
 in one question before model tool assembly. It uses the currently selected backend,
 shown in the card; selection does not prove authentication or successful inference.
+`startupDefaults.decision` and `startupDefaults.lisp` (default `ask`) mark one of those
+options as the preset; the native question UI preselects a label ending in
+` (Recommended)`, so the card still opens editable. A preset grants no authority.
 Immutable existing decision bindings also retain the task choice, without granting
 tool or file authority. The same request and explicit continuation reuse the choice;
-an unrelated new request asks again. Cancel/Skip starts no task. Headless operation
-keeps the configured decision mode and explicit manual Lisp preference; an explicit
-`typedDecisions.startup: { decision: true, lisp: true }` config selects both.
+an unrelated new request asks again. Cancel/Skip starts no task. Headless operation with `ask` keeps the
+configured decision mode and explicit manual Lisp preference; `on`/`off` supply that
+answer instead. An explicit
+`typedDecisions.startup: { decision: true, lisp: true }` config selects both and
+outranks the startup defaults for binding.
 Runtime failures retain the choice and permit explicit recovery without a new question.
 
 Semantic-comparison diagnostics retain only the known criterion names
@@ -129,7 +209,8 @@ A live comparison requires explicit
 `TYPESAFE_API_KEY`; it sends only the checked-in synthetic fixture and must not
 be interpreted as a production accuracy estimate.
 
-Set the TypeSafe key through DSH, then inspect status:
+The following commands manage only the TypeSafe/Jev key; for OpenAI, use the
+[credential-file setup](#openai-credentials). Set the TypeSafe key through DSH, then inspect status:
 
 ```text
 /kioku-typesafe-key <key>

package/docs/typesafe.md

@@ -31,9 +31,14 @@ not verified. Invoke the same command with a new key to replace it immediately.
 
 The first command reports configuration, source and writability. Clear removes
 the stored key and reports any remaining source. DSH resolves `TYPESAFE_API_KEY`
-for each call. Its inherited environment takes precedence and makes changes
-read-only; the managed credential store precedes project/user environment files.
-To change an inherited key, update that launch environment and restart DSH.
+for each call. With the standard credentials-local provider, the saved file wins,
+then the launch environment, project `.env` and harness-home `.env`. Saving writes
+the higher-priority file even when an environment fallback exists. Default file
+watching applies valid edits without a restart; an environment-only change must
+be present when DSH is launched. Preserve existing `refs` and `records`.
+See [credential paths, permissions and precedence](typed-decisions.md#openai-credentials).
+Those storage rules also apply to `TYPESAFE_API_KEY`, but `/kioku-typesafe-key`
+does not set `OPENAI_API_KEY`; ChatGPT/Codex OAuth is separate from both keys.
 With no credential provider, evaluation can use the host's `TYPESAFE_API_KEY`,
 but save/clear return `TYPESAFE_STORAGE_UNAVAILABLE`. Kiokuko creates no separate
 credential file and never supplies the key to workers or their subprocesses.

package/docs/verification.md

@@ -15,9 +15,19 @@ Native fixture preparation is deferred until a selected, executable check declar
 root dependencies (`npm ci`), not the DSH runtime fixture. Missing or invalid native
 fixtures remain `prerequisite-missing` for checks that require them.
 
-The required CI `verify` aggregate waits for `verify-main`, the complete Protected
-Lisp matrix and the complete semantic platform matrix. All three dependency results
-must be `success`; failure, cancellation, skipped or missing results fail the aggregate.
+CI schedules **Linux x64** and **macOS ARM64**. Full selection has 21 jobs:
+selection, two native micro-judge builds, 17 verification lanes and the aggregate.
+Linux ARM64 is not scheduled or claimed as CI coverage. Its runtime/build support
+remains in the native target registry; this workflow does not produce its binary.
+
+The required `verify` aggregate consumes `select`, `micro-judge-native` and `checks`.
+Every selected lane and native artifact must be present, successful, fresh and
+bound to the same selected plan and source. Failure, cancellation, a missing
+selected report, an extra target or an altered artifact fails acceptance. Only
+prose-only selection can legitimately skip both executable job groups. The
+remaining Linux x64/macOS ARM64 check inventories and their deadlines are unchanged.
+The CI review bundle contains exactly its selected targets; standalone native
+bundle verification still requires the complete supported-target inventory.
 
 Output defaults to a fresh OS temporary directory. Supply an empty directory
 outside the repository with `--output`. `plan.json`, per-command logs, official
@@ -80,6 +90,21 @@ arbitrary stdout or a successful no-op process is insufficient.
 
 ## Consolidated duplicate invocations
 
+Selected CI dependency installs set `KIOKUKO_CI_DEFER_PREPARE=1` only on the root
+`npm ci` step. With `CI=true`, this defers this package's `prepare` build to the
+verifier's required clean build; it does not disable dependency lifecycle scripts.
+Ordinary npm/pnpm preparation still builds, including in CI without this explicit
+flag, and build failure remains a failed prepare. The verifier's source/build
+digests, packed-artifact receipts and stale-source rejection remain mandatory.
+
+For full coverage, Linux ARM64 removal changes the planned job count from 27 to
+21 and official DSH fixture builds from 19 to 15. Deferring prepare removes one
+redundant plugin build in each of the remaining 17 verification lanes. This is an
+execution-plan comparison, not a measured hosted-CI duration improvement. Official
+DSH still builds separately for each selected fixture lane; no OS/architecture,
+Node/ABI or native dependency is reused across platforms.
+
+
 - `skill-prompts` is covered by `native-unit`: `tests/dsh/unit/skill-compiler.test.ts`, `tests/dsh/unit/skill-snapshot.test.ts`.
 - `index-reasoning` is covered by `native-integration`: `tests/dsh/integration/index-reasoning.test.ts`, `tests/dsh/integration/index-reasoning-native.test.ts`, `tests/dsh/integration/index-reasoning-evaluation.test.ts`.
 - `index-evaluation` is covered by `native-integration`: `tests/dsh/integration/index-reasoning-evaluation.test.ts`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiokuko-dsh",
-  "version": "0.2.36",
+  "version": "0.2.38",
   "description": "Kiokuko plugin for DeepSeek Harness",
   "type": "module",
   "license": "MIT",
@@ -24,6 +24,7 @@
     "skills/",
     "dsh/cordis.patch.yml",
     "docs/",
+    "scripts/prepare-build.mjs",
     "scripts/backfill-akinator-memory.mjs",
     "scripts/setup-dsh.mjs",
     "scripts/repair-session-log.mjs",
@@ -168,7 +169,7 @@
         "Enabled source-candidate assessment distinguishes unavailable and incomplete checks from proof; the micro judge is native-verified on Apple Silicon macOS only, unsupported platforms report unavailable, and explicit typed-decision OFF records no assessment"
       ],
       "lifecycleEvidence": [
-        "prepare runs only npm run build",
+        "prepare builds by default; selected CI installs defer to the verifier clean build",
         "Git installs use repository-scoped pnpm allowBuilds approval on a supporting pnpm version; source revision pinning is optional and separate",
         "Disposable-profile install, Web start, and uninstall evidence is recorded by CI"
       ]
@@ -201,7 +202,7 @@
     "publint": "publint",
     "pack:check": "node scripts/pack-check.mjs",
     "prepublishOnly": "node scripts/prepublish.mjs",
-    "prepare": "npm run build",
+    "prepare": "node scripts/prepare-build.mjs",
     "test:agenticreplay:package": "npm run build && node scripts/verify-agenticreplay-consumer.mjs && node scripts/verify-agenticreplay-consumer.mjs --pnpm",
     "test:memory-review": "node scripts/run-tests.mjs tests/dsh/unit/memory-review tests/dsh/integration/memory-review",
     "test:evolution": "node scripts/run-tests.mjs tests/dsh/unit/evolution tests/dsh/integration/evolution",

package/scripts/prepare-build.mjs

@@ -0,0 +1,13 @@
+// CI dependency installation may defer only this package's duplicate build.
+// Dependency lifecycle scripts still run; the selected verifier builds from source.
+import { spawnSync } from 'node:child_process'
+
+if (process.env.CI === 'true' && process.env.KIOKUKO_CI_DEFER_PREPARE === '1') {
+  console.log('Deferring package prepare build to the selected verifier clean build.')
+} else {
+  const runner=process.env.npm_execpath
+  if (!runner) throw new Error('Run prepare through npm or pnpm.')
+  const result=spawnSync(process.execPath,[runner,'run','build'],{stdio:'inherit'})
+  if (result.error) throw result.error
+  process.exitCode=result.status ?? 1
+}

package/scripts/setup-dsh.mjs

@@ -1,14 +1,19 @@
 import { parseArgs } from 'node:util'
-import { setupDsh } from '../dist/dsh/setup.js'
+import { removeDshSetup, setupDsh } from '../dist/dsh/setup.js'
 
 try {
   const { values } = parseArgs({ options: {
     cwd: { type: 'string' }, home: { type: 'string' },
     check: { type: 'boolean', default: false }, json: { type: 'boolean', default: false },
+    remove: { type: 'boolean', default: false },
   } })
-  const result = await setupDsh({ cwd: values.cwd, homeDirectory: values.home, check: values.check })
+  const result = await (values.remove ? removeDshSetup : setupDsh)({ cwd: values.cwd, homeDirectory: values.home, check: values.check })
   if (values.json) console.log(JSON.stringify(result, null, 2))
-  else {
+  else if (values.remove) {
+    console.log(values.check ? result.current ? 'Removal is current.' : 'Removal is needed; run again without --check.' : 'Removal complete.')
+    console.log(`Skills: ${result.skills.directory} (${result.skills.removed} ${values.check ? 'removable' : 'removed'}, ${result.skills.preserved} preserved)`)
+    console.log(`Project instructions: ${result.instructions.path} (${result.instructions.status})`)
+  } else {
     console.log(values.check ? result.current ? 'Setup is current.' : 'Setup needs updating; run again without --check.' : 'Setup complete. Reload existing sessions to refresh their instructions.')
     console.log(`Skills: ${result.skills.directory} (${result.skills.created} ${values.check ? 'missing' : 'created'}, ${result.skills.updated} ${values.check ? 'stale' : 'updated'}, ${result.skills.unchanged} unchanged)`)
     console.log(`Project instructions: ${result.instructions.path} (${result.instructions.status})`)