sneakoscope 10.5.5 → 10.5.7

package/README.md

@@ -8,7 +8,7 @@
 
 [![CI](https://github.com/mandarange/Sneakoscope-Codex/actions/workflows/ci.yml/badge.svg)](https://github.com/mandarange/Sneakoscope-Codex/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/sneakoscope?color=cb3837&logo=npm)](https://www.npmjs.com/package/sneakoscope)
-[![Node.js >=20.11](https://img.shields.io/badge/node-%3E%3D20.11-339933?logo=node.js&logoColor=white)](#quick-start)
+[![Recommended Node.js 24 LTS](https://img.shields.io/badge/node-24%20LTS-339933?logo=node.js&logoColor=white)](#requirements)
 [![MIT license](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 
 </div>
@@ -17,50 +17,124 @@
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-Current package: **SKS 10.5.5**. Install the latest stable release from npm.
+Current package: **SKS 10.5.7**. Install the latest stable release from npm.
 
 Sneakoscope Codex (`sks`) is a local trust layer for Codex CLI and ChatGPT Desktop. It keeps agent work bounded, preserves project context, records machine-verifiable evidence, and prevents release claims that current tests or artifacts cannot support.
 
 Use SKS when you want an AI coding session to end with something you can inspect: the change, the checks that ran, and the evidence behind the result. SKS is local-first and deterministic. It does not promise model quality, search rankings, or traffic.
 
+## SKS Center — one place for your Codex setup
+
+On macOS, **SKS Center** puts connections, subagent model choices, updates,
+and diagnostics in a native menu bar app. Open the SKS menu bar icon and choose
+**Open SKS Control Center…** to manage your setup without memorizing CLI commands.
+
+![SKS Center showing a connection-specific subagent model list with separate reasoning efforts](docs/assets/sks-center-subagent-models.png)
+
+*Native SKS Center UI with an example configuration. Models and available
+reasoning efforts depend on your connection's current catalog.*
+
+| Page | What you can manage |
+| --- | --- |
+| **Connections** | Codex-LB, OpenAI OAuth, OpenRouter, and model visibility. |
+| **Subagent Models** | Separate lists per connection, a default option, reasoning effort, and criteria for Jev. The same model can have different efforts for different work. |
+| **Decisions** | Jev's decision mode and cloud consent. |
+| **Settings** | Naruto's execution preference and app settings. |
+| **Image Generation** | Image mode, supported model choices, and provider setup. |
+| **MCP Servers** | Connected tools and server configuration. |
+| **Updates & Diagnostics** | Available updates, operation progress, logs, and health checks. |
+
+After installing SKS, install or rebuild the macOS app with:
+
+```sh
+sks menubar install
+```
+
+Interactive macOS installs can build it automatically. Dependency, CI, and
+piped installs skip the menu bar setup; scripts can opt in with
+`SKS_POSTINSTALL_MENUBAR=1` or opt out with `SKS_POSTINSTALL_NO_MENUBAR=1`.
+See [connection setup](docs/codex-lb.md), [subagent model lists](docs/naruto.md#connection-specific-subagent-lists),
+and [image generation](docs/image-generation.md) for the underlying settings.
+
 ## Quick start
 
-Requirements: Node.js **20.11+**, npm, Git, and a current Codex CLI or supported Codex desktop host.
+### Requirements
+
+- **Recommended: the latest patch release of Node.js 24 LTS.** Get it from the [official Node.js releases](https://nodejs.org/en/about/previous-releases).
+- npm, Git, and a current Codex CLI or supported Codex desktop host.
+- For source development and tests, see the locked dependency compatibility ranges in [Contributing](CONTRIBUTING.md#local-setup). CI uses the 24.x line.
+
+The published CLI's declared `package.json` engine floor is still `>=20.11`.
+That is separate from the development/test requirements above; Node 20 is now
+end-of-life, so use a supported LTS release for a new installation.
+
+### Install SKS globally
+
+Install SKS once for your user account so `sks` is available across projects:
+
+```sh
+npm install --global sneakoscope@latest
+sks doctor --fix --global-only --yes
+sks --version
+```
+
+Run these commands in your terminal. The global-only Doctor step reconciles
+user-level SKS skills and configuration, and reports any setup blockers.
+Make sure your npm global binary directory is on `PATH`.
+
+Alternatively, the verified installer performs the global npm installation,
+runs Doctor, and checks that `sks` on `PATH` resolves to the installed version:
 
 ```sh
 npm exec --yes --package=sneakoscope@latest -- sneakoscope install --yes
 ```
 
-From the root of a project you want SKS to understand:
+### Enable SKS for a project
+
+From the root of each project you want SKS to understand:
 
 ```sh
 sks bootstrap
 sks doctor --json
 ```
 
-Then open the project in Codex. Start with the smallest useful loop:
+Then open the project in Codex. Refresh its context and ask for ordinary work
+directly in the conversation:
 
 ```text
-$sks-plan "Describe the change and the checks it needs"
-$sks-work
+$sks-align
+Fix the failing test and verify the changed behavior.
 $sks-review
 ```
 
-Use the terminal to inspect the same state:
+`sks bootstrap` adds project-local SKS context and ignore rules. Ordinary work
+stays with the main agent; choose `$sks-naruto` or `$sks-work` when you want
+parallel child work.
+
+## Update an existing installation
+
+Run this from your project root in a terminal:
 
 ```sh
-sks status --json
-sks review --staged
-sks update-check
+sks update
+sks --version
+sks doctor --json
 ```
 
-The installer resolves the latest npm release, installs `sks`, runs setup and Doctor, and verifies that the command on your `PATH` is the version it installed. `sks bootstrap` adds the project-local SKS context and ignore rules; it does not replace your source of truth.
+`sks update` updates the **global** SKS package, verifies the installed command,
+and reconciles SKS-managed skills, hooks, configuration and SKS Center where
+available. In 10.5.5 and later it also repairs the known ignored Codex settings
+and refreshes managed guidance. User-authored text and explicit preferences
+are preserved. If a step fails, follow the recovery action in its output.
+
+To check available updates first, run `sks update check`. For a repair without
+requesting a newer package, run `sks doctor --fix` yourself in the terminal.
 
 ## What you get
 
 | Need | SKS provides |
 | --- | --- |
-| Keep work focused | Answers, tiny edits, ordinary implementation, reviews, and DB work run directly in the main agent, the way Codex works by default. Naruto splits work across official Codex subagents only when you ask for it. |
+| Keep work focused | Answers, tiny edits, ordinary implementation, reviews, and DB work run directly in the main agent. Naruto delegates through official Codex subagents when explicitly requested or selected by Jev. |
 | Keep context bounded | TriWiki indexes repository code into context that can be checked against source. |
 | Know what actually ran | Tests, diagnostics, and release evidence are recorded for completion claims. |
 | Recover safely | Doctor and update flows report a concrete recovery action when a check needs attention. |
@@ -73,23 +147,58 @@ and model choices are preserved. See [harness maintenance](docs/align-modernizat
 
 ## Everyday commands
 
-Inside a Codex conversation:
+### Core dollar commands
+
+Type these into the **Codex desktop app or Codex CLI conversation**:
 
 | Command | Use it for |
 | --- | --- |
+| `$sks-align` | Refresh official guidance and rebuild TriWiki from the current codebase. |
+| `$sks-mad-sks "scope and task"` | Explicitly authorize a bounded high-risk task; combine with another dollar command when appropriate. |
 | `$sks-plan "task"` | Write a plan without editing product code. |
-| `$sks-work` | Execute the latest plan with Naruto child agents. |
+| `$sks-work` | Run parallel child work through the Naruto execution alias. |
 | `$sks-review` | Review the current changes. |
 | `$sks-naruto "task"` | Explicitly split independent work across official subagents. |
 | `$sks-help` | Explore available SKS workflows. |
 
-In a terminal:
+#### `$sks-align`: keep the harness and project context current
+
+Use it when starting in a repository, after structural code changes, or when
+you want to refresh the managed instructions against current official guidance:
+
+```text
+$sks-align
+```
+
+Align searches current official Codex/model guidance, refreshes only
+SKS-managed instruction areas, and rebuilds the source-only TriWiki index.
+Your own instructions and model choices are preserved. External references
+stay separate from code facts; unavailable retrieval is reported while the
+previous references are retained. See [harness maintenance](docs/align-modernization.md).
+
+#### `$sks-mad-sks`: explicitly authorize a scoped high-risk task
+
+Name the target, allowed changes and boundaries in the request. For example:
+
+```text
+$sks-mad-sks Fix permissions only under ./dist so this project's build can run.
+Preserve source files, credentials, and other projects.
+```
+
+It temporarily widens only the approved scopes for that invocation and can
+be combined with another dollar command, such as `$sks-db` for an explicitly
+authorized database task. Database work uses the bound
+project's SQL-plane capability, read-back verification and final read-only
+restoration. Host approval boundaries and protected control-plane operations
+remain enforced. See [MAD-SKS](docs/mad-sks.md) before authorizing such work.
+
+### Terminal commands
 
 ```sh
 sks --help
 sks status --json
 sks doctor --json
-sks update-check
+sks update check
 sks update
 ```
 
@@ -106,16 +215,6 @@ SKS keeps these steps observable. It does not turn a failed check into a success
 
 ## Optional integrations
 
-### SKS Center on macOS
-
-The menu bar app exposes connections, updates, MCP servers, image generation, and diagnostics in one place. Build it from an interactive macOS install or run:
-
-```sh
-sks menubar install
-```
-
-Dependency, CI, and piped installs do not touch your home directory. Set `SKS_POSTINSTALL_MENUBAR=1` to force the build in a script, or `SKS_POSTINSTALL_NO_MENUBAR=1` to skip it.
-
 ### Desktop Bridge
 
 The Desktop Bridge can route eligible models through Codex-LB or OpenRouter while keeping provider choice and session pins explicit:
@@ -144,7 +243,8 @@ See [Image generation](docs/image-generation.md) for provider boundaries and evi
 
 - [Product contract](docs/PRODUCT-CONTRACT.md) — supported surfaces and ownership.
 - [Essential Trust](docs/essential-trust.md) — verification profiles and safety boundaries.
-- [Astra guidance](docs/astra-guidance.md) — how SKS applies official model recommendations.
+- [Harness maintenance and Align](docs/align-modernization.md) — current official references, thin managed instructions, and source-only TriWiki.
+- [MAD-SKS](docs/mad-sks.md) — explicit permission scope, execution boundaries, and verification.
 - [Agent Bridge](docs/AGENT-BRIDGE.md) — integrate through the CLI or MCP interface.
 - [Context Graph](docs/architecture/context-graph.md) — bounded source lookup and freshness.
 - [Release readiness](docs/release-readiness.md) — build, verify, and publish a release.

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "10.5.5"
+version = "10.5.7"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "10.5.5"
+version = "10.5.7"
 edition = "2021"
 
 [dependencies]

package/dist/cli/command-manifest-lite.js

@@ -70,7 +70,7 @@ const COMMAND_MANIFEST_LITE_BASE = [
     { name: 'gx', summary: 'Render/validate GX cartridges', maturity: 'labs' },
     { name: 'eval', summary: 'Run eval reports', maturity: 'labs' },
     { name: 'wiki', summary: 'Manage TriWiki and image voxel ledgers', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
-    { name: 'memory', summary: 'Project TriWiki memory into managed AGENTS.md blocks or run memory GC', maturity: 'beta' },
+    { name: 'memory', summary: 'Project TriWiki memory, explicit Jev promotion, digest-bound forgetting, or bounded recall', maturity: 'beta' },
     { name: 'gc', summary: 'Compact/prune runtime state', maturity: 'labs', skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'stats', summary: 'Show storage stats', maturity: 'labs', readonly: true, skipMigrationGate: true, allowedDuringActiveRoute: true, diagnostic: true },
     { name: 'mcp-server', summary: 'Run a stdio MCP server exposing SKS commands as tools for MCP-capable agent hosts', maturity: 'beta', skipMigrationGate: true, allowedDuringActiveRoute: true },
@@ -373,8 +373,8 @@ const COMMAND_HELP_LITE = {
         description: 'Build, refresh, publish shared shards, rebuild ignored indexes, validate, and attach wrongness-memory context to RGBA/trig LLM Wiki packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.'
     },
     memory: {
-        usage: 'sks memory build [--json] | sks memory gc [--dry-run]',
-        description: 'Project TriWiki context-pack memory into managed AGENTS.md blocks or run bounded memory cleanup.'
+        usage: 'sks memory build [--json] | sks memory gc [--dry-run] | sks memory promote --mission <id> --yes [--json] | sks memory forget --memory-id <id> --previous-digest <digest> [--json] | sks memory recall [--query <text>] [--high-risk] [--json]',
+        description: 'Project TriWiki context-pack memory, explicitly promote a Jev mission intake, write a digest-bound tombstone, or read bounded canonical memory.'
     },
     naruto: {
         usage: 'sks naruto run "task" [--agents N] [--max-threads N] [--trusted-project] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json] | sks naruto execution status [--json] | sks naruto execution set --mode auto|current-session|standalone [--restart] [--json] | sks naruto parent-summary --mission M-... --stdin [--json]',

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "10.5.5",
+  "package_version": "10.5.7",
   "skills": [
     {
       "canonical_name": "sks",

package/dist/core/agents/agent-message-bus.js

@@ -1,7 +1,153 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import { appendJsonl, nowIso } from '../fsx.js';
+import { appendJsonl, nowIso, sha256 } from '../fsx.js';
 import { appendAgentLedgerEvent } from './agent-central-ledger.js';
+export const SIBLING_MESSAGE_MAX_BYTES = 4_096;
+export const SIBLING_MESSAGE_MAX_COUNT = 8;
+export const SIBLING_MESSAGE_MAX_REPLIES = 4;
+export const SIBLING_MESSAGE_MAX_TTL_MS = 300_000;
+export const SIBLING_MESSAGE_MAX_HOPS = 1;
+export const SIBLING_MESSAGE_KINDS = Object.freeze(['need_sibling_analysis', 'evidence_request', 'handoff_clarification', 'conflict_notice']);
+const SIBLING_RELAY_LOCKS = new Map();
+async function withSiblingRelayLock(root, fn) {
+    const previous = SIBLING_RELAY_LOCKS.get(root) || Promise.resolve();
+    const next = previous.catch(() => undefined).then(fn);
+    SIBLING_RELAY_LOCKS.set(root, next.catch(() => undefined));
+    return next;
+}
+export function buildSiblingMessage(input) {
+    const created = input.created_at || nowIso();
+    const expires = input.expires_at || new Date(Date.parse(created) + 120_000).toISOString();
+    const body = String(input.body || '').trim();
+    const bodyBytes = Buffer.byteLength(body, 'utf8');
+    if (bodyBytes === 0 || bodyBytes > SIBLING_MESSAGE_MAX_BYTES)
+        throw new Error('sibling_message_body_size');
+    if (/(?:spawn|merge|publish|align|apply|permission|elevat|credential|secret|api[ _-]?key|password|token|session.?id)/i.test(body)) {
+        throw new Error('sibling_message_action_or_sensitive_content');
+    }
+    const ttlMs = Date.parse(expires) - Date.parse(created);
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0 || ttlMs > SIBLING_MESSAGE_MAX_TTL_MS)
+        throw new Error('sibling_message_ttl');
+    const message = {
+        schema: 'sks.sibling-message.v1',
+        message_id: String(input.message_id),
+        sender_task_id: String(input.sender_task_id),
+        recipient_task_id: String(input.recipient_task_id),
+        mission_id: String(input.mission_id),
+        plan_id: String(input.plan_id),
+        correlation_task_key: String(input.correlation_task_key),
+        kind: input.kind,
+        body_digest: sha256(body),
+        artifact_refs: [...new Set((input.artifact_refs || []).map(String))].filter((ref) => !ref.includes('..') && !/[\\\0]/.test(ref)).slice(0, 16),
+        reply_to: input.reply_to || null,
+        created_at: created,
+        expires_at: expires,
+        hop_count: Math.max(0, Math.floor(input.hop_count || 0)),
+        status: 'pending'
+    };
+    const validation = validateSiblingMessage(message);
+    if (!validation.ok)
+        throw new Error(`sibling_message_invalid:${validation.issues.join('|')}`);
+    return message;
+}
+export function validateSiblingMessage(value, now = Date.now(), options = {}) {
+    const row = value;
+    const issues = [];
+    if (!row || row.schema !== 'sks.sibling-message.v1')
+        issues.push('schema');
+    for (const key of ['message_id', 'sender_task_id', 'recipient_task_id', 'mission_id', 'plan_id', 'correlation_task_key', 'body_digest'])
+        if (!/^[A-Za-z0-9_.:-]{1,128}$/.test(String(row?.[key] || '')))
+            issues.push(key);
+    if (!SIBLING_MESSAGE_KINDS.includes(row?.kind))
+        issues.push('kind');
+    if (!Array.isArray(row?.artifact_refs) || row.artifact_refs.length > 16)
+        issues.push('artifact_refs');
+    if (Number(row?.hop_count) !== 0 && Number(row?.hop_count) !== SIBLING_MESSAGE_MAX_HOPS)
+        issues.push('hop_count');
+    if (!Number.isFinite(Date.parse(String(row?.created_at || ''))) || !Number.isFinite(Date.parse(String(row?.expires_at || ''))))
+        issues.push('time');
+    const ttlMs = Date.parse(String(row?.expires_at || '')) - Date.parse(String(row?.created_at || ''));
+    if (Date.parse(String(row?.expires_at || '')) <= now)
+        issues.push('expired');
+    if (ttlMs <= 0 || ttlMs > (options.maxTtlMs || SIBLING_MESSAGE_MAX_TTL_MS))
+        issues.push('ttl');
+    if (options.expectedPlanId && row?.plan_id !== options.expectedPlanId)
+        issues.push('cross_plan');
+    if (options.allowedRecipients && !options.allowedRecipients.includes(String(row?.recipient_task_id || '')))
+        issues.push('recipient');
+    if (options.mainTaskId && row?.kind === 'need_sibling_analysis' && row?.recipient_task_id !== options.mainTaskId)
+        issues.push('decomposition_recipient');
+    if (typeof row?.status !== 'string' || !['pending', 'replied', 'resolved', 'denied', 'expired'].includes(row.status))
+        issues.push('status');
+    return { ok: issues.length === 0, issues };
+}
+export async function appendSiblingMessage(root, input, options = {}) {
+    return withSiblingRelayLock(root, async () => {
+        const row = buildSiblingMessage(input);
+        const now = options.now || Date.now();
+        if (options.maxBytes !== undefined && Buffer.byteLength(String(input.body || '').trim(), 'utf8') > Math.min(SIBLING_MESSAGE_MAX_BYTES, Math.max(1, Math.floor(options.maxBytes))))
+            throw new Error('sibling_message_size_cap');
+        if (row.sender_task_id === row.recipient_task_id)
+            throw new Error('sibling_message_self_recipient');
+        if (options.planId && row.plan_id !== options.planId)
+            throw new Error('sibling_message_cross_plan');
+        if (options.parentTaskId && (options.senderParentTaskId !== options.parentTaskId || options.recipientParentTaskId !== options.parentTaskId)) {
+            throw new Error('sibling_message_parent_scope');
+        }
+        const allowedRecipients = options.allowedRecipients ? [...new Set(options.allowedRecipients.map(String))] : null;
+        if (allowedRecipients && !allowedRecipients.includes(row.recipient_task_id))
+            throw new Error('sibling_message_recipient_denied');
+        if (options.mainTaskId && row.kind === 'need_sibling_analysis' && row.recipient_task_id !== options.mainTaskId)
+            throw new Error('sibling_message_decomposition_main_only');
+        const requiredCapability = options.requiredCapability || 'sibling_discussion';
+        for (const side of [options.senderCapabilities, options.recipientCapabilities]) {
+            if (side && !side.includes(requiredCapability))
+                throw new Error('sibling_message_capability_denied');
+        }
+        const validation = validateSiblingMessage(row, now, {
+            ...(options.planId === undefined ? {} : { expectedPlanId: options.planId }),
+            ...(allowedRecipients === null ? {} : { allowedRecipients }),
+            ...(options.maxTtlMs === undefined ? {} : { maxTtlMs: options.maxTtlMs }),
+            ...(options.mainTaskId === undefined ? {} : { mainTaskId: options.mainTaskId })
+        });
+        if (!validation.ok)
+            throw new Error(`sibling_message_invalid:${validation.issues.join('|')}`);
+        const existing = await readRawAgentMessages(root);
+        const duplicate = existing.find((entry) => entry?.message_id === row.message_id && entry?.plan_id === row.plan_id);
+        if (duplicate)
+            return { ...row, duplicate: true, bus_entry: normalizeAgentMessageBusEntry(duplicate, row.mission_id) };
+        const planCount = existing.filter((entry) => entry?.plan_id === row.plan_id && entry?.mission_id === row.mission_id).length;
+        if (planCount >= Math.min(SIBLING_MESSAGE_MAX_COUNT, Math.max(1, Math.floor(options.maxCount || SIBLING_MESSAGE_MAX_COUNT))))
+            throw new Error('sibling_message_count_cap');
+        if (row.reply_to) {
+            const parent = existing.find((entry) => entry?.message_id === row.reply_to && entry?.plan_id === row.plan_id);
+            if (!parent)
+                throw new Error('sibling_message_reply_target_missing');
+            const replies = existing.filter((entry) => entry?.plan_id === row.plan_id && entry?.reply_to === row.reply_to).length;
+            if (replies >= Math.min(SIBLING_MESSAGE_MAX_REPLIES, Math.max(1, Math.floor(options.maxReplies || SIBLING_MESSAGE_MAX_REPLIES))))
+                throw new Error('sibling_message_reply_cap');
+        }
+        const entry = await appendAgentMessage(root, {
+            from: row.sender_task_id,
+            session_id: row.sender_task_id,
+            to: row.recipient_task_id,
+            body: `body_digest:${row.body_digest}`,
+            type: row.kind,
+            mission_id: row.mission_id,
+            worker_id: row.sender_task_id,
+            event_type: 'status',
+            artifact_paths: row.artifact_refs,
+            message_id: row.message_id,
+            plan_id: row.plan_id,
+            correlation_task_key: row.correlation_task_key,
+            reply_to: row.reply_to,
+            expires_at: row.expires_at,
+            hop_count: row.hop_count,
+            body_digest: row.body_digest
+        });
+        return { ...row, duplicate: false, bus_entry: entry };
+    });
+}
 export async function appendAgentMessage(root, message) {
     const eventType = normalizeAgentMessageEventType(message.event_type || message.type);
     const entry = {
@@ -18,10 +164,21 @@ export async function appendAgentMessage(root, message) {
         from: message.from,
         to: message.to || 'orchestrator',
         type: message.type || 'note',
-        body: message.body
+        body: message.body,
+        ...(message.message_id === undefined ? {} : { message_id: message.message_id }),
+        ...(message.plan_id === undefined ? {} : { plan_id: message.plan_id }),
+        ...(message.correlation_task_key === undefined ? {} : { correlation_task_key: message.correlation_task_key }),
+        ...(message.reply_to === undefined ? {} : { reply_to: message.reply_to }),
+        ...(message.expires_at === undefined ? {} : { expires_at: message.expires_at }),
+        ...(message.hop_count === undefined ? {} : { hop_count: message.hop_count }),
+        ...(message.body_digest === undefined ? {} : { body_digest: message.body_digest })
     };
     await appendJsonl(path.join(root, 'agent-messages.jsonl'), entry);
-    await appendAgentLedgerEvent(root, { agent_id: message.from, session_id: message.session_id, event_type: 'message_appended', payload: { to: entry.to, type: entry.type } });
+    await appendAgentLedgerEvent(root, { agent_id: message.from, session_id: message.session_id, event_type: 'message_appended', payload: {
+            to: entry.to, type: entry.type, message_id: entry.message_id || null, plan_id: entry.plan_id || null,
+            correlation_task_key: entry.correlation_task_key || null, reply_to: entry.reply_to || null,
+            expires_at: entry.expires_at || null, hop_count: entry.hop_count ?? null, body_digest: entry.body_digest || null
+        } });
     return entry;
 }
 export async function readAgentMessageBus(root, missionId, opts = {}) {
@@ -74,9 +231,28 @@ function normalizeAgentMessageBusEntry(value, missionId) {
         from: value.from == null ? undefined : String(value.from),
         to: value.to == null ? undefined : String(value.to),
         type: value.type == null ? undefined : String(value.type),
-        body: value.body == null ? undefined : String(value.body)
+        body: value.body == null ? undefined : String(value.body),
+        message_id: value.message_id == null ? undefined : String(value.message_id),
+        plan_id: value.plan_id == null ? undefined : String(value.plan_id),
+        correlation_task_key: value.correlation_task_key == null ? undefined : String(value.correlation_task_key),
+        reply_to: value.reply_to == null ? value.reply_to : String(value.reply_to),
+        expires_at: value.expires_at == null ? undefined : String(value.expires_at),
+        hop_count: value.hop_count == null ? undefined : Number(value.hop_count),
+        body_digest: value.body_digest == null ? undefined : String(value.body_digest)
     };
 }
+async function readRawAgentMessages(root) {
+    const file = path.join(root, 'agent-messages.jsonl');
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    return text.split(/\n+/).filter(Boolean).flatMap((line) => {
+        try {
+            return [JSON.parse(line)];
+        }
+        catch {
+            return [];
+        }
+    });
+}
 function normalizeAgentMessageEventType(value) {
     const text = String(value || '').toLowerCase();
     if (text === 'worker_completed' || text === 'completed' || text === 'done')

package/dist/core/agents/native-worker-backend-router.js

@@ -14,7 +14,7 @@ import { decideSubagentModel } from '../subagents/model-policy.js';
 import { latestTierModelSet } from '../subagents/model-tiers.js';
 import { consultJevTurnModel } from '../decisions/integration.js';
 import { chooseChildModel, fallbackChildModel } from '../decisions/child-model-choice.js';
-import { allowlistedChildModel, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort, isSubagentModelEffort } from '../subagents/child-model-allowlist.js';
+import { allowlistedChildModel, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort, isSubagentModelEffort, isAllowedChildModelEffort } from '../subagents/child-model-allowlist.js';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -317,28 +317,31 @@ async function resolveOpenRouterOnlyWorkerRouting(input, deps, ctx) {
         ? allowlistedChildModel(input.agent?.routed_model, allowlist)
         : null;
     const requested = String(input.agent?.routed_model || input.agent?.model || '').trim() || null;
+    const requestedEffort = explicitReasoning || String(input.agent?.routed_model_reasoning_effort || input.agent?.model_reasoning_effort || '') || null;
     const explicitListed = explicitModel ? allowlistedChildModel(explicitModel, allowlist) : null;
     const task = `${ctx.taskKindText}\n${ctx.riskText}`.trim().slice(0, 1200);
     const choice = explicitModel
-        ? (explicitListed ? fallbackChildModel(state, explicitListed, 'explicit') : null)
+        ? (explicitListed ? fallbackChildModel(state, explicitListed, 'explicit', requestedEffort) : null)
         : planned
-            ? fallbackChildModel(state, planned, 'planned')
+            ? fallbackChildModel(state, planned, 'planned', requestedEffort)
             : deps.consultJev === false || !task
-                ? fallbackChildModel(state, requested, deps.consultJev === false ? 'jev_skipped' : 'empty_task')
-                : await chooseChildModel({ root: deps.root || process.cwd(), task, role: input.agent?.role || null, requestedModel: requested, state, env, profile: childModelListProfile(allowlist) })
-                    .catch(() => fallbackChildModel(state, requested, 'consult_failed'));
+                ? fallbackChildModel(state, requested, deps.consultJev === false ? 'jev_skipped' : 'empty_task', requestedEffort)
+                : await chooseChildModel({ root: deps.root || process.cwd(), task, role: input.agent?.role || null, requestedModel: requested, requestedEffort, state, env, profile: childModelListProfile(allowlist) })
+                    .catch(() => fallbackChildModel(state, requested, 'consult_failed', requestedEffort));
     const taskPolicy = decideSubagentModel({ title: ctx.taskKindText, description: ctx.riskText, role: input.agent?.role });
     const choiceModel = choice?.entry.model || '';
     const routed = {
         model: choiceModel,
-        reasoning: allowlist.mode === 'openrouter_only'
-            ? explicitReasoning || choice?.entry.reasoning_effort || listReasoning(taskPolicy.modelReasoningEffort) || 'medium'
-            : explicitReasoning || (choice ? listChildModelEffort(choice.entry, null) : null),
+        reasoning: choice ? listChildModelEffort(choice.entry, requestedEffort
+            || (allowlist.mode === 'openrouter_only' ? listReasoning(taskPolicy.modelReasoningEffort) || 'medium' : null)) : null,
         serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
     };
     const blockers = [
         ...(!allowlist.entries.length ? [allowlist.mode === 'openrouter_only' ? 'openrouter_only_subagent_list_empty' : 'configured_subagent_list_unavailable'] : []),
         ...(explicitModel && !explicitListed ? [allowlist.mode === 'openrouter_only' ? 'openrouter_only_subagent_model_not_listed' : 'configured_subagent_model_not_listed'] : []),
+        ...(explicitListed && choiceModel !== explicitListed ? ['subagent_model_effort_ambiguous'] : []),
+        ...(rawEffort && (!explicitReasoning || !isAllowedChildModelEffort(choiceModel, explicitReasoning, allowlist)
+            || explicitReasoning !== routed.reasoning) ? ['subagent_effort_conflicts_with_list'] : []),
         ...(allowlist.mode === 'configured' && rawEffort
             && (!explicitReasoning || !choice?.entry.supported_reasoning_efforts?.includes(explicitReasoning))
             ? ['configured_subagent_effort_unsupported'] : []),