odai-dsh-agent 0.0.7 → 0.0.9

package/README.md

@@ -13,7 +13,7 @@ $DSH_HOME/.agent-presets/odai/
   .odai-agent.json
 ```
 
-The composition preserves every capability row and setting from the `standard` agent surface in `@deepseek-ai/dsh@0.1.0-rc.6`, then adds the scoped Odai runtime in default `auto` mode. Release verification compares the complete derived composition against that exact DSH Standard source; a missing, added, reordered, or changed Standard row fails the probe. Host-owned persistence, sandbox, approval, registries, and base controller selection remain in the selected DSH profile. Ordinary requests stay on that controller. A complete contextual high-impact decision gap upgrades the same turn only when a planner mapping exists; the controller's durable `request/header` proves the actual route. Explicit independent planning/review requests still start a verified child when their mappings exist. `execute` remains an explicit all-delegation comparison mode. `observe` changes no model and starts no child; it injects a local evidence-and-decision protocol and makes an unresolved high-impact turn read-only. For DSH compaction on the same provider/model, an omitted summarizer reasoning setting inherits the session's current user-selected reasoning effort so the auxiliary call remains cache-compatible; explicit and cross-model settings are not changed.
+The composition preserves every capability row and setting from the `standard` agent surface in `@deepseek-ai/dsh@0.1.0-rc.6`, then adds the scoped Odai runtime in default `auto` mode. Release verification compares the complete derived composition against that exact DSH Standard source; a missing, added, reordered, or changed Standard row fails the probe. Host-owned persistence, sandbox, approval, registries, and base controller selection remain in the selected DSH profile. Ordinary requests stay on that controller. A complete contextual high-impact decision gap upgrades the same turn only when a planner mapping exists; the controller's durable `request/header` proves the actual route. Explicit independent planning/review requests still start a verified child when their mappings exist. `execute` remains an explicit all-delegation comparison mode. `observe` changes no model and starts no child; it injects a local evidence-and-decision protocol and makes an unresolved high-impact turn read-only. For DSH compaction, an explicit user-selected summary reasoning effort overrides only that auxiliary call. When omitted, same-provider/model compaction inherits the session's current reasoning effort for cache compatibility; a cross-model target removes an effort matching that durable route, while a distinct preselected effort is preserved because the request envelope exposes no stronger provenance.
 
 ## Install
 
@@ -67,7 +67,13 @@ Natural requests include `use normal output`, `use soft concise output`, `enable
 
 An economy ceiling only tightens an existing lower host request value and is not a locally enforceable hard billing boundary. A provider may count hidden reasoning inside it, exceed or ignore it, or end before useful final text, especially at a high reasoning effort; strict compliance must be checked from per-request usage. Odai enables economy only when requested and never invents a non-default custom value. The mode does not alter child-agent role budgets, compaction, checkpoints, or other internal context; an incomplete token-capped compaction fails closed instead of replacing history.
 
-A same-provider/model compaction that inherits controller reasoning also requests long prompt-cache retention while keeping its independent summary budget. Explicit compaction retention is preserved. `ODAI_COMPACTION_CACHE_RETENTION=provider-default` restores the host default; `short`, `long`, and `none` are also accepted deployment overrides. The first controller request after a landed summary still rebuilds the changed summary prefix.
+A same-provider/model compaction inherits controller reasoning while keeping its independent summary budget. Odai leaves prompt-cache retention unset by default; `ODAI_COMPACTION_CACHE_RETENTION` can explicitly select `short`, `long`, or `none`. `provider-default` means Odai adds no retention, while any explicit incoming retention remains authoritative; configured retention still applies when host routing has already supplied reasoning. Custom preset compositions can set the same value through runtime `compaction.cacheRetention`. The first controller request after a landed summary still rebuilds the changed summary prefix.
+
+## Compaction model
+
+The default compaction-summary model is `inherit`, which preserves the conversation's current provider/model behavior. A user can explicitly set a separate target and optional reasoning effort in natural language, such as `压缩模型用 provider-x/model-summary，推理档 high`; `odai_compaction_config` persists those explicit values in `$DSH_HOME/odai/compaction.json`. Removing the target restores inheritance. Agent and Plugin share the store when both are deliberately present.
+
+The target applies only to future `compaction` summary requests. It does not change the controller, planner, executor, reviewer, ordinary conversation, summary output budget, or cache-retention policy. An explicitly configured `reasoningEffort` overrides reasoning only for those summaries. When omitted, existing behavior remains: same-route summaries can inherit controller reasoning, while a cross-model target removes only reasoning proven by equality with the durable controller route and preserves a distinct preselected effort. Each configured target receives one provider-neutral integrity suffix that keeps current facts above superseded/rejected history, preserves continuation-critical opaque values exactly, and self-checks contradictions; duplicate Agent/Plugin runtime instances add it only once. Odai never chooses the provider, model, or reasoning effort on the user's behalf. An invalid store is reported by the tool while runtime requests inherit safely until `set` or `remove` repairs it. An unavailable route, provider error, or incomplete summary fails closed: DSH retains the original history rather than replacing it with a partial checkpoint.
 
 ## Skill sources
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "odai-dsh-agent",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "完整继承 DSH 标准模式 全部能力的 Odai Agent preset。主要用于治理、规划、测试、验证 等，可当成默认总控使用。",
   "license": "MIT",
   "repository": {

package/preset/odai/runtime/compaction-config.mjs

@@ -0,0 +1,357 @@
+import { randomUUID } from "node:crypto";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+
+import { acquireOwnedStoreLock } from "./store-lock.mjs";
+
+const STORE_SCHEMA_VERSION = 1;
+const TARGET_FIELDS = new Set(["provider", "model", "reasoningEffort"]);
+const STATE_PROTOCOL_SOURCE = Object.freeze({
+  kind: "plugin",
+  plugin: "odai-dsh-runtime",
+  form: "instructions",
+});
+
+export const COMPACTION_STATE_PROTOCOL = [
+  "Additional checkpoint integrity protocol:",
+  "- Treat facts explicitly marked CURRENT, corrected, or authoritative as the active state.",
+  "- Facts marked SUPERSEDED, REJECTED, obsolete, or historical may be retained only as rejected history; never describe them as current, latest, selected, or pending.",
+  "- Preserve opaque identifiers, paths, commands, status values, delimiters, and numeric values byte-for-byte when they determine continuation state.",
+  "- Before emitting the checkpoint, self-check that no rejected fact is framed as active and that no active value conflicts with another section.",
+].join("\n");
+
+export const COMPACTION_CONFIG_PROMPT = [
+  "## Odai compaction model configuration",
+  "When the user naturally asks to inspect, set, change, or reset the model or reasoning effort used to summarize compacted context, use odai_compaction_config.",
+  "Set a compaction target only when the user explicitly supplies both provider and model. Pass reasoningEffort only when the user explicitly supplies it. Never infer or silently choose any value. If the user changes only the effort for an existing persisted target, inspect and preserve that exact provider/model pair.",
+  "The default is inherit: compaction uses the current conversation route. A configured target changes only compaction-summary requests; it does not change the controller, planner, executor, reviewer, normal conversation, summary output budget, or cache-retention policy. An optional explicit reasoning effort is likewise scoped only to compaction summaries; omitting it preserves the existing reasoning inheritance and cross-model isolation behavior.",
+  "Configured targets also receive a provider-neutral checkpoint integrity protocol that keeps current facts above superseded or rejected history and preserves continuation-critical opaque values exactly.",
+  "Do not ask the user to edit YAML, JSON, managed Agent files, or Plugin configuration. The tool owns persistence. Set/remove changes apply to the next compaction request.",
+  "An invalid persisted store is visible through the tool while runtime requests safely inherit the conversation route. If the configured route fails or produces an incomplete summary, DSH must preserve the original history rather than landing a partial checkpoint.",
+].join("\n");
+
+export class CompactionModelStoreValidationError extends Error {}
+
+function assertPlainObject(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value;
+}
+
+export function resolveCompactionTarget(value, field = "Odai compaction model target") {
+  const target = assertPlainObject(value, field);
+  const unknown = Object.keys(target).filter((name) => !TARGET_FIELDS.has(name));
+  if (unknown.length > 0) throw new TypeError(`${field} has unknown fields: ${unknown.join(", ")}`);
+  if (typeof target.provider !== "string" || target.provider.trim() === "") {
+    throw new TypeError(`${field}.provider must be a non-empty string`);
+  }
+  if (typeof target.model !== "string" || target.model.trim() === "") {
+    throw new TypeError(`${field}.model must be a non-empty string`);
+  }
+  if (target.reasoningEffort !== undefined
+    && (typeof target.reasoningEffort !== "string" || target.reasoningEffort.trim() === "")) {
+    throw new TypeError(`${field}.reasoningEffort must be a non-empty string`);
+  }
+  return Object.freeze({
+    provider: target.provider.trim(),
+    model: target.model.trim(),
+    ...(target.reasoningEffort === undefined ? {} : { reasoningEffort: target.reasoningEffort.trim() }),
+  });
+}
+
+export function resolveCompactionConfigPath(configuredPath, env = process.env) {
+  if (configuredPath !== undefined) {
+    if (typeof configuredPath !== "string" || configuredPath.trim() === "") {
+      throw new TypeError("config.compaction.configPath must be a non-empty string");
+    }
+    return resolve(configuredPath.trim());
+  }
+  const dshHome = typeof env.DSH_HOME === "string" && env.DSH_HOME.trim() !== ""
+    ? resolve(env.DSH_HOME.trim())
+    : resolve(homedir(), ".dsh");
+  return resolve(dshHome, "odai", "compaction.json");
+}
+
+export function readCompactionModelStore(configPath) {
+  let text;
+  try {
+    text = readFileSync(configPath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return Object.freeze({ schemaVersion: STORE_SCHEMA_VERSION });
+    throw new Error(`cannot read Odai compaction model configuration ${configPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new CompactionModelStoreValidationError(`Odai compaction model configuration ${configPath} is not valid JSON`, { cause: error });
+  }
+  try {
+    const store = assertPlainObject(parsed, `Odai compaction model configuration ${configPath}`);
+    const unknown = Object.keys(store).filter((field) => !["schemaVersion", "target"].includes(field));
+    if (unknown.length > 0) {
+      throw new TypeError(`Odai compaction model configuration ${configPath} has unknown fields: ${unknown.join(", ")}`);
+    }
+    if (store.schemaVersion !== STORE_SCHEMA_VERSION) {
+      throw new TypeError(`Odai compaction model configuration ${configPath} has unsupported schemaVersion ${String(store.schemaVersion)}`);
+    }
+    if (store.target === undefined) return Object.freeze({ schemaVersion: STORE_SCHEMA_VERSION });
+    return Object.freeze({
+      schemaVersion: STORE_SCHEMA_VERSION,
+      target: resolveCompactionTarget(store.target, `Odai compaction model configuration ${configPath}.target`),
+    });
+  } catch (error) {
+    if (error instanceof CompactionModelStoreValidationError) throw error;
+    throw new CompactionModelStoreValidationError(
+      `Odai compaction model configuration ${configPath} failed validation: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    );
+  }
+}
+
+export function effectiveCompactionTarget(configPath) {
+  const stored = readCompactionModelStore(configPath);
+  return Object.freeze({
+    ...(stored.target === undefined ? {} : { target: stored.target }),
+    source: stored.target === undefined ? "inherit" : "persisted",
+  });
+}
+
+export function applyCompactionTarget(options, target, sessions) {
+  if (options?.purpose !== "compaction" || target === undefined) return false;
+  const currentRoute = options.sessionId === undefined
+    ? undefined
+    : sessions?.get?.(options.sessionId)?.requestHeader?.()?.config;
+  const durableRouteKnown = typeof currentRoute?.provider === "string"
+    && currentRoute.provider.length > 0
+    && typeof currentRoute.model === "string"
+    && currentRoute.model.length > 0;
+  const targetChangesDurableRoute = durableRouteKnown
+    && (currentRoute.provider !== target.provider || currentRoute.model !== target.model);
+  const inheritedReasoning = targetChangesDurableRoute
+    && typeof currentRoute.reasoningEffort === "string"
+    && currentRoute.reasoningEffort.length > 0
+    && options.reasoningEffort === currentRoute.reasoningEffort;
+  const changesRoute = options.provider !== target.provider || options.model !== target.model;
+  const changesReasoning = target.reasoningEffort !== undefined
+    && options.reasoningEffort !== target.reasoningEffort;
+  if (!changesRoute && !inheritedReasoning && !changesReasoning) return false;
+  if (!Object.isExtensible(options)) {
+    throw new Error("configured Odai compaction model cannot be applied to an immutable request");
+  }
+
+  if (target.reasoningEffort !== undefined) options.reasoningEffort = target.reasoningEffort;
+  else if (inheritedReasoning) delete options.reasoningEffort;
+  if (changesRoute) {
+    options.provider = target.provider;
+    options.model = target.model;
+  }
+  return true;
+}
+
+export function applyCompactionStateProtocol(options, target) {
+  if (options?.purpose !== "compaction" || target === undefined) return false;
+  if (!Array.isArray(options.messages) || !Object.isExtensible(options)) {
+    throw new Error("configured Odai compaction model requires a mutable message envelope for checkpoint integrity");
+  }
+  const alreadyApplied = options.messages.some((message) => (
+    message?.source?.kind === STATE_PROTOCOL_SOURCE.kind
+    && message.source.plugin === STATE_PROTOCOL_SOURCE.plugin
+    && message.source.form === STATE_PROTOCOL_SOURCE.form
+    && Array.isArray(message.content)
+    && message.content.some((block) => block?.type === "text" && block.text === COMPACTION_STATE_PROTOCOL)
+  ));
+  if (alreadyApplied) return false;
+  options.messages = [...options.messages, {
+    id: randomUUID(),
+    role: "user",
+    content: [{ type: "text", text: COMPACTION_STATE_PROTOCOL }],
+    source: STATE_PROTOCOL_SOURCE,
+  }];
+  return true;
+}
+
+function writeCompactionModelStore(configPath, target) {
+  mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
+  const temporary = `${configPath}.tmp-${process.pid}-${randomUUID()}`;
+  const value = `${JSON.stringify({ schemaVersion: STORE_SCHEMA_VERSION, target }, null, 2)}\n`;
+  try {
+    writeFileSync(temporary, value, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    renameSync(temporary, configPath);
+  } finally {
+    rmSync(temporary, { force: true });
+  }
+}
+
+function preserveInvalidStore(configPath) {
+  try {
+    renameSync(configPath, `${configPath}.invalid-${Date.now()}-${randomUUID()}`);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+function resultFor(configPath, action, selection, recoveredInvalidStore = false) {
+  return {
+    action,
+    configPath,
+    source: selection.source,
+    ...(selection.target === undefined ? {} : { target: selection.target }),
+    requiresNextCompaction: action !== "show",
+    ...(selection.invalidStore ? { invalidStore: true } : {}),
+    ...(recoveredInvalidStore ? { recoveredInvalidStore: true } : {}),
+  };
+}
+
+export function createCompactionConfigTool(configPath, options = {}) {
+  const onConfigured = typeof options.onConfigured === "function" ? options.onConfigured : () => {};
+  const isChild = typeof options.isChild === "function"
+    ? options.isChild
+    : (agent) => {
+      const header = agent?.session?.header;
+      return header?.origin === "subagent"
+        || (Number.isSafeInteger(header?.delegationDepth) && header.delegationDepth > 0);
+    };
+  return {
+    name: "odai_compaction_config",
+    description: [
+      "Inspect, set, or remove the shared Odai compaction-summary target.",
+      "Use only when the user naturally asks about the compaction model/reasoning effort or explicitly supplies the provider and model to set. Never select a provider, model, or reasoning effort on the user's behalf.",
+      "The default is inherit. A persisted target changes only future compaction-summary requests; controller and responsibility routes, output budget, and cache retention stay unchanged. An optional user-specified reasoning effort applies only to those summaries.",
+      "Persisted targets also receive a provider-neutral integrity protocol that keeps current facts above superseded history and preserves continuation-critical opaque values exactly.",
+      "An invalid store is reported while runtime requests safely inherit. If the configured route or summary fails, DSH preserves the original history. Changes apply from the next compaction request.",
+    ].join(" "),
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      required: ["action"],
+      properties: {
+        action: {
+          type: "string",
+          enum: ["show", "set", "remove"],
+          description: "Show the effective target, set a user-specified provider/model and optional reasoning effort, or remove it to restore inheritance.",
+        },
+        provider: {
+          type: "string",
+          description: "Provider id explicitly supplied by the user; required for set.",
+        },
+        model: {
+          type: "string",
+          description: "Model id explicitly supplied by the user; required for set.",
+        },
+        reasoningEffort: {
+          type: "string",
+          description: "Optional compaction reasoning effort explicitly supplied by the user.",
+        },
+      },
+    },
+    output: {
+      schema: {
+        type: "object",
+        additionalProperties: false,
+        required: ["action", "configPath", "source", "requiresNextCompaction"],
+        properties: {
+          action: { type: "string", enum: ["show", "set", "remove"] },
+          configPath: { type: "string" },
+          source: { type: "string", enum: ["inherit", "persisted"] },
+          target: {
+            type: "object",
+            additionalProperties: false,
+            required: ["provider", "model"],
+            properties: {
+              provider: { type: "string" },
+              model: { type: "string" },
+              reasoningEffort: { type: "string" },
+            },
+          },
+          requiresNextCompaction: { type: "boolean" },
+          invalidStore: { type: "boolean" },
+          recoveredInvalidStore: { type: "boolean" },
+        },
+      },
+      render(_args, value) {
+        const target = value.target
+          ? `${value.target.provider}/${value.target.model} (reasoning: ${value.target.reasoningEffort ?? "not configured"})`
+          : "inherit the current conversation model and reasoning";
+        return [{
+          type: "text",
+          text: [
+            `${value.action === "show" ? "Current" : "Updated"} Odai compaction target (${value.source}): ${target}.`,
+            " This affects compaction summaries only; other model routes, the summary budget, and cache retention are unchanged.",
+            ...(value.invalidStore ? [" The persisted store is invalid, so runtime requests currently inherit; set or remove the target to repair it."] : []),
+            ...(value.recoveredInvalidStore ? [" An invalid prior store was preserved before the configuration was repaired or reset."] : []),
+            ...(value.requiresNextCompaction ? [" The change applies from the next compaction request."] : []),
+          ].join(""),
+        }];
+      },
+    },
+    execute(args, execution) {
+      if (!execution.agent) throw new Error("odai_compaction_config requires an owning agent session");
+      if (isChild(execution.agent)) throw new Error("child agents may not change Odai compaction model configuration");
+      if (!args || typeof args !== "object" || Array.isArray(args)) throw new TypeError("arguments must be an object");
+      const unknown = Object.keys(args).filter((field) => !["action", "provider", "model", "reasoningEffort"].includes(field));
+      if (unknown.length > 0) throw new TypeError(`unknown arguments: ${unknown.join(", ")}`);
+      if (!["show", "set", "remove"].includes(args.action)) throw new TypeError("action must be show, set, or remove");
+      if (args.action === "show") {
+        if (args.provider !== undefined || args.model !== undefined || args.reasoningEffort !== undefined) {
+          throw new TypeError("provider, model, and reasoningEffort must be omitted for show");
+        }
+        let selection;
+        try {
+          selection = effectiveCompactionTarget(configPath);
+        } catch (error) {
+          if (!(error instanceof CompactionModelStoreValidationError)) throw error;
+          selection = Object.freeze({ source: "inherit", invalidStore: true });
+        }
+        return Promise.resolve(resultFor(configPath, "show", selection));
+      }
+      if (args.action === "remove"
+        && (args.provider !== undefined || args.model !== undefined || args.reasoningEffort !== undefined)) {
+        throw new TypeError("provider, model, and reasoningEffort must be omitted for remove");
+      }
+      const proposed = args.action === "set"
+        ? resolveCompactionTarget({
+            provider: args.provider,
+            model: args.model,
+            ...(args.reasoningEffort === undefined ? {} : { reasoningEffort: args.reasoningEffort }),
+          })
+        : undefined;
+
+      const releaseLock = acquireOwnedStoreLock(configPath, "Odai compaction model configuration");
+      try {
+        let recoveredInvalidStore = false;
+        try {
+          readCompactionModelStore(configPath);
+        } catch (error) {
+          if (!(error instanceof CompactionModelStoreValidationError)) {
+            throw new Error("Odai compaction model configuration could not be read safely; no changes were made", { cause: error });
+          }
+          recoveredInvalidStore = preserveInvalidStore(configPath);
+        }
+        if (args.action === "set") writeCompactionModelStore(configPath, proposed);
+        else rmSync(configPath, { force: true });
+        const selection = args.action === "set"
+          ? Object.freeze({ target: proposed, source: "persisted" })
+          : Object.freeze({ source: "inherit" });
+        onConfigured(execution.agent, {
+          action: args.action,
+          ...(selection.target === undefined ? {} : { target: selection.target }),
+          ...(recoveredInvalidStore ? { recoveredInvalidStore: true } : {}),
+        });
+        return Promise.resolve(resultFor(configPath, args.action, selection, recoveredInvalidStore));
+      } finally {
+        releaseLock();
+      }
+    },
+  };
+}

package/preset/odai/runtime/index.mjs

@@ -35,6 +35,14 @@ import {
   resolveOutputConfigPath,
 } from "./output-config.mjs";
 import { selectSharedOutputPolicyForTurn } from "./output-policy-state.mjs";
+import {
+  COMPACTION_CONFIG_PROMPT,
+  applyCompactionStateProtocol,
+  applyCompactionTarget,
+  createCompactionConfigTool,
+  effectiveCompactionTarget,
+  resolveCompactionConfigPath,
+} from "./compaction-config.mjs";
 import { createSessionEvidence, resolveSessionEvidenceRoot } from "./session-evidence.mjs";
 import {
   SKILL_SOURCE_CONFIG_PROMPT,
@@ -86,12 +94,13 @@ export function resolveConfig(rawConfig = {}) {
   const skillSource = governance.skillSource ?? "bundled";
   const skillConfigPath = resolveSkillSourceConfigPath(governance.skillConfigPath);
   const outputConfigPath = resolveOutputConfigPath(output.configPath);
+  const compactionConfigPath = resolveCompactionConfigPath(compaction.configPath);
   const compactionCacheRetention = compaction.cacheRetention
     ?? process.env.ODAI_COMPACTION_CACHE_RETENTION
-    ?? "long";
+    ?? "provider-default";
   const unknownRoles = Object.keys(roles).filter((role) => !ROUTED_ROLES.includes(role));
   const unknownOutputFields = Object.keys(output).filter((field) => field !== "configPath");
-  const unknownCompactionFields = Object.keys(compaction).filter((field) => field !== "cacheRetention");
+  const unknownCompactionFields = Object.keys(compaction).filter((field) => !["cacheRetention", "configPath"].includes(field));
 
   if (!ROUTING_MODES.has(mode)) {
     throw new TypeError("config.routing.mode must be off, observe, auto, or execute");
@@ -143,13 +152,16 @@ export function resolveConfig(rawConfig = {}) {
       skillConfigPath,
     }),
     output: Object.freeze({ configPath: outputConfigPath }),
-    compaction: Object.freeze({ cacheRetention: compactionCacheRetention }),
+    compaction: Object.freeze({
+      cacheRetention: compactionCacheRetention,
+      configPath: compactionConfigPath,
+    }),
   });
 }
 
-export function inheritCompactionReasoning(options, sessions, cacheRetention = "long") {
+/** Mutate exact-route compaction options; returns true only when an option changed. */
+export function inheritCompactionReasoning(options, sessions, cacheRetention = "provider-default") {
   if (options?.purpose !== "compaction"
-    || options.reasoningEffort !== undefined
     || options.sessionId === undefined
     || !Object.isExtensible(options)) {
     return false;
@@ -163,11 +175,16 @@ export function inheritCompactionReasoning(options, sessions, cacheRetention = "
     return false;
   }
 
-  options.reasoningEffort = route.reasoningEffort;
+  let changed = false;
+  if (options.reasoningEffort === undefined) {
+    options.reasoningEffort = route.reasoningEffort;
+    changed = true;
+  }
   if (options.cacheRetention === undefined && cacheRetention !== "provider-default") {
     options.cacheRetention = cacheRetention;
+    changed = true;
   }
-  return true;
+  return changed;
 }
 
 export function resolveSkillPath(configuredPath, env = process.env) {
@@ -382,8 +399,21 @@ export function apply(ctx, rawConfig) {
     }
   };
   const hasSessionEvent = (agent, type, predicate) => evidence.has(agent, type, predicate);
+  const selectCompactionTarget = () => {
+    try {
+      return effectiveCompactionTarget(config.compaction.configPath);
+    } catch (error) {
+      logger.warn(`Odai compaction model configuration is invalid; inheriting the conversation route: ${error instanceof Error ? error.message : String(error)}`);
+      return Object.freeze({ source: "inherit", status: "fallback", reasonCode: "compaction-config-invalid" });
+    }
+  };
   ctx.on("llm/stream", (options, next) => {
-    inheritCompactionReasoning(options, ctx.sessions, config.compaction.cacheRetention);
+    if (options?.purpose === "compaction") {
+      const selection = selectCompactionTarget();
+      applyCompactionTarget(options, selection.target, ctx.sessions);
+      applyCompactionStateProtocol(options, selection.target);
+      inheritCompactionReasoning(options, ctx.sessions, config.compaction.cacheRetention);
+    }
     return next();
   });
   const skillPath = resolveSkillPath(config.skillPath);
@@ -424,6 +454,11 @@ export function apply(ctx, rawConfig) {
     order: -17,
     text: "",
   });
+  ctx.systemPrompt.section({
+    name: "odai:compaction-model-configuration",
+    order: -16,
+    text: COMPACTION_CONFIG_PROMPT,
+  });
 
   const optionalSkillRegistry = () => {
     try {
@@ -568,6 +603,12 @@ export function apply(ctx, rawConfig) {
       appendEvent(agent, "odai/output-configured", data);
     },
   }));
+  ctx.tools.register(createCompactionConfigTool(config.compaction.configPath, {
+    isChild: isSubagent,
+    onConfigured(agent, data) {
+      appendEvent(agent, "odai/compaction-configured", data);
+    },
+  }));
   ctx.tools.guard((execution) => childGuard(execution) ?? routeProtectionGuard(execution));
 
   ctx.on("tools/result", (execution, result) => {