kiokuko-dsh 0.1.0

package/docs/security-and-trust.md

@@ -0,0 +1,39 @@
+# Security and trust
+
+## Memory and secrets
+
+Kiokuko refuses content that resembles passwords, API keys, tokens, private keys,
+or similar secrets. It does not store full conversations. Memory is advisory and
+must not override current code, configuration, or execution evidence.
+
+## External Skills
+
+External Skill discovery is reference-only. Kiokuko verifies a source commit, stores
+bounded content as an untrusted candidate, and never installs, runs, or registers
+fetched Skill content automatically. `official` is the default discovery mode;
+`community` is explicit opt-in and `off` disables discovery.
+
+Inspect or manage mappings with:
+
+```bash
+kiokuko skills find svelte --official-only --json
+kiokuko skills list
+kiokuko skills disable <skill-id>
+kiokuko skills refresh <skill-id>
+```
+
+The Web UI can inspect and disable mappings, but has no install, script, or MCP
+registration action.
+
+## MCP extensions and public errors
+
+Codex `ToolLifecycleContributor` and other client extensions can inspect or replace successful and error MCP results. They are
+therefore part of the trusted computing base; Kiokuko cannot claim end-to-end
+authenticity without an extension-unforgeable original-result identifier and modified
+flag. Do not combine Kiokuko with an extension that changes critical results.
+
+Normal public tool failures use `isError: true` with an allowlisted message plus
+`structuredContent.code` and `structuredContent.retryable`; only `BACKPRESSURE` may
+include bounded `retryAfterSeconds`. Raw stacks, SQL, paths, payloads, and secrets
+are not copied into generic errors. Specialized validation and recovery errors retain
+only their bounded purpose-specific fields.

package/docs/security.md

@@ -0,0 +1,11 @@
+# Embedding security
+
+The local-small preset fixes the repository, full revision, required files,
+sizes, and SHA-256 values. Arbitrary repositories, URLs, paths, extensions,
+and remote code are not accepted. Files are verified before model loading;
+staging is private and final installation is atomic.
+
+Status, doctor, progress, and errors do not include memory text, query text,
+credentials, redirect URLs, or absolute model paths. Legacy embedding
+environment variables are detected by name only and are not used as runtime
+configuration.

package/docs/semantic-retrieval.ja.md

@@ -0,0 +1,18 @@
+# Semantic retrieval
+
+軽量インストールではlexical検索が動きます。semantic検索は任意のlocal `local-small` embedding profileです。
+
+```bash
+kiokuko embeddings setup
+kiokuko embeddings status --json
+kiokuko embeddings repair
+```
+
+固定runtimeを導入し、load前にartifactを検証します。`--offline`は検証済みlocal installationを要求し、`--dry-run`はdownload・書き込み・profile変更を行いません。
+`--replace`は別profileから切り替えます。model weightはnpm packageに含めません。
+
+このコマンドは通常のclient setup flowも実行し、managed MCP blockとproject instructionsを更新します。完全一致の旧managed blockは自動更新します。
+unmanagedまたは改変されたidentityは対話確認が必要で、JSON・非対話・dry-run自動化では設定を変えずfail closedします。
+
+runtime、model、vectorに障害があってもlexical検索と既存vectorは利用できます。`status`と`doctor --json`でcoverageとhealthを確認します。
+embedding設定は環境変数ではなくSQLiteに保存します。

package/docs/semantic-retrieval.md

@@ -0,0 +1,26 @@
+# Semantic retrieval
+
+Lexical retrieval works in the lightweight install. Semantic retrieval is an
+optional local `local-small` embedding profile.
+
+```bash
+kiokuko embeddings setup
+kiokuko embeddings status --json
+kiokuko embeddings repair
+```
+
+Setup installs only the pinned runtime and verifies every artifact before loading
+it. `--offline` requires an already verified local installation; `--dry-run` does
+not download, write, or change the active profile; `--replace` switches from a
+different active profile. Model weights are not included in the npm package.
+
+The command also runs the normal client setup flow: managed MCP blocks and project
+instructions are refreshed. Exact old managed blocks are upgraded automatically.
+An unmanaged or tampered identity requires interactive confirmation; JSON,
+non-interactive, and dry-run automation fails closed with no configuration change.
+
+If the local runtime, model, or vectors are unavailable, lexical retrieval and old
+vectors remain usable. `status` and `doctor --json` expose coverage and health.
+Embedding configuration is stored in SQLite, not environment variables. Platform-
+specific runtime installation details and allowlists are kept in the implementation
+references and release checks.

package/docs/sqlite-driver-adr.md

@@ -0,0 +1,8 @@
+# SQLite driver ADR
+
+Kiokuko keeps JavaScript exact-cosine search as the portable fallback and uses
+the package-owned sqlite-vec extension only when the configured backend is
+`auto` or `sqlite-vec` and the extension loads successfully. The setup model
+and embedding profile are independent of that backend choice. Extension
+loading is disabled immediately after a successful load, and user-provided
+native extension paths are not accepted.

package/dsh/cordis.patch.yml

@@ -0,0 +1,7 @@
+# Kiokuko's DeepSeek Harness bundle layer. The host Loader owns lifecycle and
+# the package entrypoint owns the Cordis effects.
+- insert:
+    - id: kiokuko-dsh
+      name: 'kiokuko-dsh/dsh'
+      config:
+        enabled: true

package/migrations/001_initial.sql

@@ -0,0 +1,123 @@
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    name TEXT NOT NULL,
+    checksum TEXT NOT NULL,
+    applied_at TEXT NOT NULL
+);
+
+CREATE TABLE repositories (
+    repository_id TEXT PRIMARY KEY,
+    workspace TEXT NOT NULL UNIQUE,
+    display_name TEXT NOT NULL,
+    remote_fingerprint TEXT,
+    binding_schema_version INTEGER NOT NULL,
+    agent_template_version INTEGER NOT NULL,
+    created_at TEXT NOT NULL,
+    last_used_at TEXT NOT NULL
+);
+
+CREATE TABLE repository_locations (
+    repository_id TEXT NOT NULL REFERENCES repositories(repository_id),
+    canonical_root TEXT NOT NULL UNIQUE,
+    first_seen_at TEXT NOT NULL,
+    last_seen_at TEXT NOT NULL,
+    PRIMARY KEY (repository_id, canonical_root)
+);
+
+CREATE TABLE entries (
+    id TEXT PRIMARY KEY,
+    workspace TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (
+        status IN ('candidate', 'verified', 'superseded')
+    ),
+    trust_level TEXT NOT NULL DEFAULT 'user_asserted' CHECK (
+        trust_level IN ('untrusted', 'user_asserted', 'source_verified', 'system_verified')
+    ),
+    confidence REAL NOT NULL CHECK (confidence >= 0.0 AND confidence <= 1.0),
+    current_revision INTEGER NOT NULL CHECK (current_revision > 0),
+    superseded_by TEXT REFERENCES entries(id),
+    created_by TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    verified_at TEXT,
+    CHECK (status != 'superseded' OR superseded_by IS NOT NULL)
+);
+
+CREATE UNIQUE INDEX idx_entries_id_workspace
+    ON entries(id, workspace);
+CREATE INDEX idx_entries_workspace_status
+    ON entries(workspace, status, updated_at DESC);
+
+CREATE TABLE entry_revisions (
+    entry_id TEXT NOT NULL,
+    workspace TEXT NOT NULL,
+    revision INTEGER NOT NULL CHECK (revision > 0),
+    kind TEXT NOT NULL CHECK (
+        kind IN ('fact', 'decision', 'lesson', 'preference', 'reference')
+    ),
+    title TEXT NOT NULL,
+    body TEXT NOT NULL,
+    summary TEXT,
+    scope_json TEXT NOT NULL DEFAULT '{}',
+    provenance_json TEXT NOT NULL DEFAULT '{}',
+    content_hash TEXT NOT NULL,
+    created_by TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (entry_id, revision),
+    FOREIGN KEY (entry_id, workspace)
+        REFERENCES entries(id, workspace)
+        ON DELETE CASCADE
+);
+
+CREATE UNIQUE INDEX idx_entry_revisions_workspace_hash
+    ON entry_revisions(workspace, content_hash);
+CREATE INDEX idx_entry_revisions_entry_created
+    ON entry_revisions(entry_id, revision DESC);
+
+CREATE TABLE entry_revision_tags (
+    entry_id TEXT NOT NULL,
+    revision INTEGER NOT NULL,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (entry_id, revision, tag),
+    FOREIGN KEY (entry_id, revision)
+        REFERENCES entry_revisions(entry_id, revision)
+        ON DELETE CASCADE
+);
+
+CREATE INDEX idx_entry_revision_tags_tag
+    ON entry_revision_tags(tag, entry_id, revision);
+
+CREATE TRIGGER entry_revisions_immutable_update
+BEFORE UPDATE ON entry_revisions
+BEGIN
+    SELECT RAISE(ABORT, 'entry_revisions are immutable');
+END;
+
+CREATE TRIGGER entry_revision_tags_immutable_update
+BEFORE UPDATE ON entry_revision_tags
+BEGIN
+    SELECT RAISE(ABORT, 'entry_revision_tags are immutable');
+END;
+
+CREATE TABLE entry_links (
+    from_entry_id TEXT NOT NULL REFERENCES entries(id),
+    to_entry_id TEXT NOT NULL REFERENCES entries(id),
+    relation TEXT NOT NULL CHECK (
+        relation IN ('supports', 'contradicts', 'derived_from', 'related_to')
+    ),
+    created_at TEXT NOT NULL,
+    created_by TEXT NOT NULL,
+    PRIMARY KEY (from_entry_id, to_entry_id, relation)
+);
+
+CREATE TABLE audit_events (
+    event_id TEXT PRIMARY KEY,
+    entry_id TEXT REFERENCES entries(id),
+    workspace TEXT NOT NULL,
+    operation TEXT NOT NULL CHECK (
+        operation IN ('record', 'promote', 'supersede', 'link', 'import', 'purge')
+    ),
+    actor TEXT NOT NULL,
+    details_json TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL
+);

package/migrations/002_fts.sql

@@ -0,0 +1,22 @@
+CREATE VIRTUAL TABLE entries_fts USING fts5(
+    title,
+    body,
+    summary,
+    tags_text,
+    tokenize='unicode61 remove_diacritics 2'
+);
+
+-- FTS is an application-controlled projection of the current revision. There
+-- are deliberately no triggers on entries or tags: historical revisions must
+-- never become searchable and projection refreshes must be explicit.
+INSERT INTO entries_fts(rowid, title, body, summary, tags_text)
+SELECT e.rowid,
+       r.title,
+       r.body,
+       COALESCE(r.summary, ''),
+       COALESCE((SELECT group_concat(tag, ' ')
+                   FROM entry_revision_tags
+                  WHERE entry_id = e.id AND revision = e.current_revision), '')
+  FROM entries AS e
+  JOIN entry_revisions AS r
+    ON r.entry_id = e.id AND r.revision = e.current_revision;

package/migrations/003_akinator.sql

@@ -0,0 +1,30 @@
+CREATE TABLE akinator_sessions (
+    id TEXT PRIMARY KEY,
+    workspace TEXT NOT NULL,
+    task_text TEXT NOT NULL,
+    profile_json TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('active', 'ready', 'exhausted')),
+    question_count INTEGER NOT NULL DEFAULT 0 CHECK (question_count >= 0),
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_akinator_sessions_workspace
+    ON akinator_sessions(workspace, updated_at DESC);
+
+CREATE TABLE akinator_answers (
+    session_id TEXT NOT NULL REFERENCES akinator_sessions(id) ON DELETE CASCADE,
+    question_id TEXT NOT NULL,
+    answer_json TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (session_id, question_id)
+);
+
+CREATE TABLE knowledge_sources (
+    source_id TEXT PRIMARY KEY,
+    repository_url TEXT NOT NULL UNIQUE,
+    ref_name TEXT NOT NULL,
+    commit_sha TEXT NOT NULL,
+    document_count INTEGER NOT NULL DEFAULT 0,
+    last_synced_at TEXT NOT NULL
+);

package/migrations/004_agent_gateway.sql

@@ -0,0 +1,261 @@
+CREATE TABLE ledger_runs (
+    run_id TEXT PRIMARY KEY,
+    workspace TEXT NOT NULL,
+    client_kind TEXT NOT NULL,
+    client_version TEXT,
+    source_session_id TEXT,
+    parent_run_id TEXT REFERENCES ledger_runs(run_id) ON DELETE SET NULL,
+    protocol_version TEXT NOT NULL,
+    capture_profile TEXT NOT NULL,
+    coverage_json TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (
+        status IN ('intake', 'active', 'completed', 'failed', 'cancelled', 'interrupted')
+    ),
+    title TEXT,
+    task_hash TEXT,
+    metadata_json TEXT NOT NULL,
+    last_sequence INTEGER NOT NULL DEFAULT 0 CHECK (last_sequence >= 0),
+    last_source_sequence INTEGER,
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_ledger_runs_workspace_status_created_at
+    ON ledger_runs(workspace, status, created_at DESC);
+CREATE INDEX idx_ledger_runs_parent
+    ON ledger_runs(parent_run_id);
+
+CREATE TABLE run_intakes (
+    run_id TEXT PRIMARY KEY REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    session_id TEXT NOT NULL UNIQUE REFERENCES akinator_sessions(id),
+    policy_version TEXT NOT NULL,
+    profile_schema_version INTEGER NOT NULL CHECK (profile_schema_version > 0),
+    profile_sources_json TEXT NOT NULL,
+    initial_profile_hash TEXT,
+    recommended_tags_json TEXT NOT NULL,
+    linked_at TEXT NOT NULL,
+    finalized_at TEXT
+);
+
+CREATE INDEX idx_run_intakes_session
+    ON run_intakes(session_id);
+
+CREATE TRIGGER run_intakes_workspace_guard
+BEFORE INSERT ON run_intakes
+BEGIN
+    SELECT RAISE(ABORT, 'run_intakes workspace mismatch')
+    WHERE (SELECT workspace FROM ledger_runs WHERE run_id = NEW.run_id) IS NULL
+       OR (SELECT workspace FROM akinator_sessions WHERE id = NEW.session_id) IS NULL
+       OR (SELECT workspace FROM ledger_runs WHERE run_id = NEW.run_id)
+          <> (SELECT workspace FROM akinator_sessions WHERE id = NEW.session_id);
+END;
+
+CREATE TRIGGER run_intakes_workspace_update_guard
+BEFORE UPDATE OF run_id, session_id ON run_intakes
+BEGIN
+    SELECT RAISE(ABORT, 'run_intakes workspace mismatch')
+    WHERE (SELECT workspace FROM ledger_runs WHERE run_id = NEW.run_id) IS NULL
+       OR (SELECT workspace FROM akinator_sessions WHERE id = NEW.session_id) IS NULL
+       OR (SELECT workspace FROM ledger_runs WHERE run_id = NEW.run_id)
+          <> (SELECT workspace FROM akinator_sessions WHERE id = NEW.session_id);
+END;
+
+CREATE TRIGGER run_intakes_parent_workspace_guard
+BEFORE UPDATE OF workspace ON ledger_runs
+WHEN EXISTS (SELECT 1 FROM run_intakes WHERE run_id = OLD.run_id)
+BEGIN
+    SELECT RAISE(ABORT, 'workspace cannot change after run intake link');
+END;
+
+CREATE TRIGGER run_intakes_session_workspace_guard
+BEFORE UPDATE OF workspace ON akinator_sessions
+WHEN EXISTS (SELECT 1 FROM run_intakes WHERE session_id = OLD.id)
+BEGIN
+    SELECT RAISE(ABORT, 'workspace cannot change after run intake link');
+END;
+
+CREATE TABLE intake_feedback (
+    feedback_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    session_id TEXT NOT NULL REFERENCES akinator_sessions(id),
+    question_id TEXT,
+    profile_field TEXT,
+    verdict TEXT NOT NULL CHECK (verdict IN ('helpful', 'unnecessary', 'corrected')),
+    comment TEXT,
+    actor TEXT NOT NULL,
+    idempotency_key TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    UNIQUE (run_id, actor, idempotency_key),
+    CHECK ((question_id IS NOT NULL) <> (profile_field IS NOT NULL))
+);
+
+CREATE INDEX idx_intake_feedback_run_created_at
+    ON intake_feedback(run_id, created_at DESC);
+
+CREATE TRIGGER intake_feedback_link_guard
+BEFORE INSERT ON intake_feedback
+BEGIN
+    SELECT RAISE(ABORT, 'intake_feedback requires the linked run and session')
+    WHERE NOT EXISTS (
+        SELECT 1 FROM run_intakes
+        WHERE run_id = NEW.run_id AND session_id = NEW.session_id
+    );
+END;
+
+CREATE TABLE ledger_events (
+    event_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    sequence INTEGER NOT NULL CHECK (sequence > 0),
+    source_event_id TEXT,
+    source_sequence INTEGER,
+    event_type TEXT NOT NULL,
+    source_type TEXT,
+    actor TEXT NOT NULL,
+    outcome TEXT,
+    occurred_at TEXT,
+    ingested_at TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    redaction_json TEXT NOT NULL,
+    previous_hash TEXT NOT NULL,
+    event_hash TEXT NOT NULL,
+    UNIQUE (run_id, sequence)
+);
+
+CREATE INDEX idx_ledger_events_run_sequence
+    ON ledger_events(run_id, sequence);
+CREATE UNIQUE INDEX idx_ledger_events_run_source
+    ON ledger_events(run_id, source_event_id)
+    WHERE source_event_id IS NOT NULL;
+
+CREATE TABLE ledger_evidence (
+    evidence_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    event_id TEXT REFERENCES ledger_events(event_id) ON DELETE SET NULL,
+    kind TEXT NOT NULL CHECK (kind IN ('command', 'test', 'file', 'diff', 'url', 'artifact')),
+    locator TEXT NOT NULL,
+    digest_algorithm TEXT,
+    digest TEXT,
+    byte_size INTEGER CHECK (byte_size IS NULL OR byte_size >= 0),
+    summary TEXT,
+    created_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_ledger_evidence_run_created_at
+    ON ledger_evidence(run_id, created_at DESC);
+
+CREATE TABLE context_deliveries (
+    delivery_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    through_sequence INTEGER NOT NULL CHECK (through_sequence >= 0),
+    intake_session_id TEXT REFERENCES akinator_sessions(id),
+    task_profile_hash TEXT NOT NULL,
+    query_hash TEXT NOT NULL,
+    policy_version TEXT NOT NULL,
+    external_sync_summary_json TEXT NOT NULL,
+    char_budget INTEGER NOT NULL CHECK (char_budget >= 0),
+    char_count INTEGER NOT NULL CHECK (char_count >= 0 AND char_count <= char_budget),
+    truncated INTEGER NOT NULL CHECK (truncated IN (0, 1)),
+    created_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_context_deliveries_run_created_at
+    ON context_deliveries(run_id, created_at DESC);
+
+CREATE TABLE context_delivery_entries (
+    delivery_id TEXT NOT NULL REFERENCES context_deliveries(delivery_id) ON DELETE CASCADE,
+    entry_id TEXT NOT NULL,
+    entry_revision INTEGER NOT NULL CHECK (entry_revision > 0),
+    rank INTEGER NOT NULL CHECK (rank > 0),
+    score_components_json TEXT NOT NULL,
+    selection_reason_json TEXT NOT NULL,
+    PRIMARY KEY (delivery_id, entry_id),
+    FOREIGN KEY (entry_id, entry_revision)
+        REFERENCES entry_revisions(entry_id, revision)
+);
+
+CREATE INDEX idx_context_delivery_entries_entry
+    ON context_delivery_entries(entry_id, entry_revision);
+
+CREATE TABLE context_feedback (
+    feedback_id TEXT PRIMARY KEY,
+    delivery_id TEXT NOT NULL REFERENCES context_deliveries(delivery_id) ON DELETE CASCADE,
+    entry_id TEXT NOT NULL REFERENCES entries(id),
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    verdict TEXT NOT NULL CHECK (verdict IN ('helpful', 'irrelevant', 'stale', 'conflicting')),
+    comment TEXT,
+    actor TEXT NOT NULL,
+    idempotency_key TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    UNIQUE (run_id, actor, idempotency_key)
+);
+
+CREATE INDEX idx_context_feedback_run
+    ON context_feedback(run_id, created_at DESC);
+
+CREATE TABLE run_feedback (
+    feedback_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    outcome TEXT,
+    recommendation_code TEXT,
+    recommendation_verdict TEXT CHECK (recommendation_verdict IS NULL OR recommendation_verdict IN ('accepted', 'dismissed', 'resolved')),
+    rating INTEGER CHECK (rating IS NULL OR (rating >= 1 AND rating <= 5)),
+    comment TEXT,
+    actor TEXT NOT NULL,
+    idempotency_key TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    UNIQUE (run_id, actor, idempotency_key)
+);
+
+CREATE INDEX idx_run_feedback_run_created_at
+    ON run_feedback(run_id, created_at DESC);
+
+CREATE TABLE ledger_memory_links (
+    link_id TEXT PRIMARY KEY,
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    event_id TEXT REFERENCES ledger_events(event_id) ON DELETE SET NULL,
+    delivery_id TEXT REFERENCES context_deliveries(delivery_id) ON DELETE SET NULL,
+    entry_id TEXT NOT NULL REFERENCES entries(id),
+    created_at TEXT NOT NULL,
+    CHECK (event_id IS NOT NULL OR delivery_id IS NOT NULL)
+);
+
+CREATE INDEX idx_ledger_memory_links_run
+    ON ledger_memory_links(run_id, created_at DESC);
+CREATE INDEX idx_ledger_memory_links_entry
+    ON ledger_memory_links(entry_id);
+
+CREATE TABLE ledger_purge_audit (
+    purge_id TEXT PRIMARY KEY,
+    run_id TEXT REFERENCES ledger_runs(run_id) ON DELETE SET NULL,
+    event_id TEXT REFERENCES ledger_events(event_id) ON DELETE SET NULL,
+    delivery_id TEXT REFERENCES context_deliveries(delivery_id) ON DELETE SET NULL,
+    entry_id TEXT REFERENCES entries(id) ON DELETE SET NULL,
+    target_type TEXT NOT NULL CHECK (target_type IN ('run', 'event', 'evidence', 'delivery', 'feedback', 'memory_link')),
+    target_id TEXT NOT NULL,
+    actor TEXT NOT NULL,
+    reason TEXT,
+    created_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_ledger_purge_audit_target
+    ON ledger_purge_audit(target_type, target_id);
+
+CREATE TABLE gateway_idempotency (
+    scope TEXT NOT NULL,
+    key_hash TEXT NOT NULL CHECK (
+        length(key_hash) = 64
+        AND key_hash NOT GLOB '*[^0-9a-f]*'
+    ),
+    request_hash TEXT NOT NULL CHECK (
+        length(request_hash) = 64
+        AND request_hash NOT GLOB '*[^0-9a-f]*'
+    ),
+    response_json TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    PRIMARY KEY (scope, key_hash)
+);
+
+CREATE INDEX idx_gateway_idempotency_created_at
+    ON gateway_idempotency(created_at);

package/migrations/005_hybrid_search.sql

@@ -0,0 +1,40 @@
+-- Current-revision hybrid-search projections. Historical revisions are never
+-- indexed; application code refreshes these projections after each mutation.
+CREATE VIRTUAL TABLE entries_trigram USING fts5(
+    title,
+    body,
+    summary,
+    tags_text,
+    tokenize='trigram'
+);
+
+CREATE TABLE entry_search_signals (
+    entry_id TEXT NOT NULL REFERENCES entries(id) ON DELETE CASCADE,
+    signal_type TEXT NOT NULL CHECK (
+        signal_type IN ('language', 'framework', 'runtime', 'database', 'tool',
+                        'platform', 'package', 'symbol', 'path', 'error', 'command', 'tag')
+    ),
+    normalized_value TEXT NOT NULL,
+    PRIMARY KEY (entry_id, signal_type, normalized_value)
+);
+
+CREATE INDEX idx_entry_search_signals_lookup
+    ON entry_search_signals(signal_type, normalized_value);
+
+INSERT INTO entries_trigram(rowid, title, body, summary, tags_text)
+SELECT e.rowid,
+       r.title,
+       r.body,
+       COALESCE(r.summary, ''),
+       COALESCE((SELECT group_concat(tag, ' ')
+                   FROM entry_revision_tags
+                  WHERE entry_id = e.id AND revision = e.current_revision), '')
+  FROM entries AS e
+  JOIN entry_revisions AS r
+    ON r.entry_id = e.id AND r.revision = e.current_revision;
+
+INSERT INTO entry_search_signals(entry_id, signal_type, normalized_value)
+SELECT t.entry_id, 'tag', lower(trim(t.tag))
+  FROM entry_revision_tags AS t
+  JOIN entries AS e ON e.id = t.entry_id AND e.current_revision = t.revision
+ WHERE length(trim(t.tag)) > 0;

package/migrations/006_context_v2.sql

@@ -0,0 +1,4 @@
+-- Versioned context metadata. Existing v1 rows retain their original meaning
+-- through defaults; new deliveries may identify global-origin entries.
+ALTER TABLE context_deliveries ADD COLUMN score_schema_version INTEGER NOT NULL DEFAULT 1 CHECK (score_schema_version >= 1);
+ALTER TABLE context_delivery_entries ADD COLUMN origin_scope TEXT NOT NULL DEFAULT 'project' CHECK (origin_scope IN ('project', 'global'));

package/migrations/007_akinator_reasoning.sql

@@ -0,0 +1,59 @@
+-- Successful Akinator narrowing paths are durable evidence for Curator.
+-- Retrieval impressions are deliberately excluded: only checkpointed runs can
+-- insert rows into this table through the application service.
+CREATE TABLE akinator_reasoning_paths (
+    path_id TEXT PRIMARY KEY,
+    concept_key TEXT NOT NULL CHECK (
+        length(concept_key) = 64
+        AND concept_key NOT GLOB '*[^0-9a-f]*'
+    ),
+    entry_id TEXT NOT NULL REFERENCES entries(id) ON DELETE CASCADE,
+    entry_revision INTEGER NOT NULL CHECK (entry_revision > 0),
+    run_id TEXT NOT NULL REFERENCES ledger_runs(run_id) ON DELETE CASCADE,
+    intake_session_id TEXT NOT NULL REFERENCES akinator_sessions(id) ON DELETE CASCADE,
+    workspace TEXT NOT NULL,
+    policy_version TEXT NOT NULL,
+    task_type TEXT NOT NULL,
+    intent TEXT NOT NULL,
+    hypotheses_json TEXT NOT NULL,
+    question_path_json TEXT NOT NULL,
+    selected_action TEXT NOT NULL,
+    conditions_json TEXT NOT NULL,
+    verification_json TEXT NOT NULL,
+    stop_conditions_json TEXT NOT NULL,
+    silo_completeness REAL NOT NULL CHECK (silo_completeness >= 0 AND silo_completeness <= 1),
+    outcome TEXT NOT NULL CHECK (outcome IN ('completed', 'failed', 'cancelled', 'interrupted')),
+    qualified INTEGER NOT NULL CHECK (qualified IN (0, 1)),
+    disqualification_reasons_json TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    UNIQUE (run_id, entry_id, entry_revision)
+);
+
+CREATE INDEX idx_akinator_reasoning_paths_concept
+    ON akinator_reasoning_paths(concept_key, qualified, created_at DESC);
+
+CREATE INDEX idx_akinator_reasoning_paths_entry
+    ON akinator_reasoning_paths(entry_id, entry_revision, created_at DESC);
+
+CREATE TRIGGER akinator_reasoning_paths_link_guard
+BEFORE INSERT ON akinator_reasoning_paths
+BEGIN
+    SELECT RAISE(ABORT, 'akinator reasoning path link mismatch')
+    WHERE NOT EXISTS (
+        SELECT 1
+          FROM run_intakes AS ri
+          JOIN ledger_runs AS lr ON lr.run_id = ri.run_id
+          JOIN akinator_sessions AS a ON a.id = ri.session_id
+         WHERE ri.run_id = NEW.run_id
+           AND ri.session_id = NEW.intake_session_id
+           AND lr.workspace = NEW.workspace
+           AND a.workspace = NEW.workspace
+    ) OR NOT EXISTS (
+        SELECT 1
+        FROM entries AS e
+        JOIN entry_revisions AS er
+          ON er.entry_id = e.id AND er.revision = NEW.entry_revision
+         WHERE e.id = NEW.entry_id
+           AND er.workspace IN (NEW.workspace, 'global')
+    );
+END;