odai-dsh-agent 0.0.4 → 0.0.6

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.
+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.
 
 ## Install
 
@@ -53,6 +53,16 @@ The controller calls `odai_routing_config` to persist that explicit choice. The
 
 Planner, executor, and reviewer are independent optional responsibilities. If any needed one has no mapping, high-impact work fails closed and remains read-only; lower-impact work continues only where it does not depend on the missing independent responsibility. Odai never chooses a model on the user's behalf.
 
+## Skill sources
+
+The Agent keeps the managed preset's complete skill copy as its `bundled` default, so existing installations do not change behavior. When the user explicitly asks to show, set, or reset the Odai skill source, the controller uses `odai_skill_source_config` and stores the choice in `$DSH_HOME/odai/source.json`, outside the managed preset:
+
+- `bundled`: use the skill shipped with this Agent release.
+- `auto`: allow a compatible current-project `.dsh/skills/odai` or `.agents/skills/odai` bundle, then DSH custom roots and newer user installs under `$DSH_HOME/skills/odai` or `$DSH_AGENTS_HOME/skills/odai` (default `~/.agents/skills/odai`), with bundled fallback.
+- `user`: ignore project roots and require a compatible custom or user-level bundle. An unusable source produces an explicit bundled fallback diagnostic so it can be repaired through the same tool.
+
+An independent install must be a complete directory bundle containing `SKILL.md`, `manifest.json`, and every manifest-declared file. The runtime checks SemVer 2.0.0 `skillVersion`, an exact supported `runtimeContract`, complete-file SHA-256 integrity, and same-version content conflicts. Prompt governance and routing role contracts are selected atomically for one agent turn; project sources are scoped by that session's cwd, and changes are reconsidered on the next user turn. Explicit deployment `skillPath` or `ODAI_SKILL_PATH` remains highest priority and requires a DSH restart.
+
 ## Status and uninstall
 
 ```sh
@@ -71,7 +81,7 @@ Use only the surface that matches the desired scope:
 - `odai-dsh-agent`: selectable Odai governance for only sessions using this preset.
 - both: supported only for a deliberate combination of profile-wide and Agent-scoped behavior; normally redundant, so it is not the default recommendation.
 
-When both are deliberate, the shared compatibility-safe evidence store deduplicates tool and route records and denials remain monotonic. Neither package installs or changes the provider-neutral `odai-cli`.
+When both are deliberate, a process-shared per-agent/per-turn skill snapshot keeps prompt governance and role contracts identical, the compatibility-safe evidence store deduplicates tool and route records, and denials remain monotonic. Neither package installs or changes the provider-neutral `odai-cli`.
 
 ## Development
 

package/bin/odai-dsh-agent.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { readDshVersion } from "../src/dsh-version.mjs";
 import {

package/package.json

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

package/preset/odai/runtime/index.mjs

@@ -1,11 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
   decideRoute,
-  extractLatestUserText,
+  extractRoutingText,
   renderDelegationPrompt,
   renderMissingRouteConfigNotice,
   renderRouteFailureNotice,
@@ -27,9 +27,26 @@ import {
   resolveRoutingConfigPath,
 } from "./routing-config.mjs";
 import { createSessionEvidence, resolveSessionEvidenceRoot } from "./session-evidence.mjs";
+import {
+  SKILL_SOURCE_CONFIG_PROMPT,
+  createSkillSourceConfigTool,
+  effectiveSkillSource,
+  resolveSkillSourceConfigPath,
+} from "./skill-source-config.mjs";
+import {
+  ODAI_RUNTIME_CONTRACT,
+  SKILL_SOURCE_MODES,
+  loadSkillBundle,
+} from "./skill-bundle.mjs";
+import { resolveSkillSelection } from "./skill-selector.mjs";
+import {
+  currentAgentTurn,
+  selectSharedSkillForTurn,
+  sharedSkillSelection,
+} from "./skill-selection-state.mjs";
 
 export const name = "odai-dsh-runtime";
-export const inject = ["systemPrompt", "tools", "subagents"];
+export const inject = ["systemPrompt", "tools", "subagents", "sessions"];
 
 const PLUGIN_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const ROUTING_MODES = new Set(["off", "observe", "auto", "execute"]);
@@ -54,6 +71,8 @@ export function resolveConfig(rawConfig = {}) {
   const maxInputChars = routing.maxInputChars ?? 12_000;
   const configPath = resolveRoutingConfigPath(routing.configPath);
   const additionalDeniedTools = governance.additionalDeniedTools ?? [];
+  const skillSource = governance.skillSource ?? "bundled";
+  const skillConfigPath = resolveSkillSourceConfigPath(governance.skillConfigPath);
   const unknownRoles = Object.keys(roles).filter((role) => !ROUTED_ROLES.includes(role));
 
   if (!ROUTING_MODES.has(mode)) {
@@ -72,6 +91,9 @@ export function resolveConfig(rawConfig = {}) {
     || additionalDeniedTools.some((tool) => typeof tool !== "string" || tool.trim() === "")) {
     throw new TypeError("config.governance.additionalDeniedTools must be an array of non-empty strings");
   }
+  if (!SKILL_SOURCE_MODES.includes(skillSource)) {
+    throw new TypeError("config.governance.skillSource must be bundled, auto, or user");
+  }
   if (raw.skillPath !== undefined && (typeof raw.skillPath !== "string" || raw.skillPath.trim() === "")) {
     throw new TypeError("config.skillPath must be a non-empty string");
   }
@@ -90,32 +112,51 @@ export function resolveConfig(rawConfig = {}) {
     }),
     governance: Object.freeze({
       additionalDeniedTools: Object.freeze(additionalDeniedTools.map((tool) => tool.trim())),
+      skillSource,
+      skillConfigPath,
     }),
   });
 }
 
-export function resolveSkillPath(configuredPath) {
+export function inheritCompactionReasoning(options, sessions) {
+  if (options?.purpose !== "compaction"
+    || options.reasoningEffort !== undefined
+    || options.sessionId === undefined
+    || !Object.isExtensible(options)) {
+    return false;
+  }
+
+  const route = sessions?.get?.(options.sessionId)?.requestHeader?.()?.config;
+  if (route?.provider !== options.provider
+    || route?.model !== options.model
+    || typeof route.reasoningEffort !== "string"
+    || route.reasoningEffort.length === 0) {
+    return false;
+  }
+
+  options.reasoningEffort = route.reasoningEffort;
+  return true;
+}
+
+export function resolveSkillPath(configuredPath, env = process.env) {
+  const explicit = configuredPath ?? env.ODAI_SKILL_PATH;
+  if (explicit !== undefined) {
+    const path = resolve(explicit);
+    if (!existsSync(path)) throw new Error(`explicit Odai canonical skill not found: ${path}`);
+    return path;
+  }
+
   const candidates = [
-    configuredPath,
-    process.env.ODAI_SKILL_PATH,
     resolve(PLUGIN_DIR, "skills/odai/SKILL.md"),
     resolve(PLUGIN_DIR, "../../skills/odai/SKILL.md"),
-  ].filter(Boolean).map((candidate) => resolve(candidate));
-
+  ];
   const found = candidates.find((candidate) => existsSync(candidate));
   if (found) return found;
-
-  throw new Error(`odai canonical skill not found; checked: ${candidates.join(", ")}`);
+  throw new Error(`Odai bundled canonical skill not found; checked: ${candidates.join(", ")}`);
 }
 
 export function loadRoleContracts(skillPath) {
-  const roleRoot = resolve(dirname(skillPath), "assets/routing-roles");
-  return Object.freeze(Object.fromEntries(ROUTED_ROLES.map((role) => {
-    const path = resolve(roleRoot, `${role}.md`);
-    const text = existsSync(path) ? readFileSync(path, "utf8").trim() : "";
-    if (!text) throw new Error(`odai canonical ${role} role is unavailable: ${path}`);
-    return [role, text];
-  })));
+  return loadSkillBundle(skillPath).roleContracts;
 }
 
 function deepFreeze(value) {
@@ -263,13 +304,20 @@ export async function runRoutedRole({ subagents, provider, decision, taskText, r
   return outcome;
 }
 
-function canonicalPrompt(skillPath, skillText) {
+function canonicalPrompt(selection) {
+  const { bundle } = selection;
+  const fallback = selection.status === "fallback"
+    ? `Selection fallback: ${selection.reasonCode}${selection.detail ? ` (${selection.detail})` : ""}.`
+    : undefined;
   return [
     "## odai canonical governance",
-    `Canonical source: ${skillPath}`,
+    `Canonical source: ${bundle.source} (${bundle.provider})`,
+    `Canonical skill: ${bundle.manifest.skillVersion}; runtime contract: ${bundle.manifest.runtimeContract}; digest: ${bundle.digest}.`,
+    ...(fallback ? [fallback] : []),
     "Apply this governance to every request. Keep the controller as the final delivery owner; use another role only for a real independent gap with observable net benefit.",
+    "Odai governance is already loaded by this runtime; do not call the skill tool to load odai again.",
     "",
-    skillText,
+    bundle.skillText,
   ].join("\n");
 }
 
@@ -302,21 +350,108 @@ export function apply(ctx, rawConfig) {
     }
   };
   const hasSessionEvent = (agent, type, predicate) => evidence.has(agent, type, predicate);
+  ctx.on("llm/stream", (options, next) => {
+    inheritCompactionReasoning(options, ctx.sessions);
+    return next();
+  });
   const skillPath = resolveSkillPath(config.skillPath);
-  const skillText = readFileSync(skillPath, "utf8").trim();
-  if (!skillText) throw new Error(`odai canonical skill is empty: ${skillPath}`);
-  const roleContracts = loadRoleContracts(skillPath);
+  const explicitSkillPath = config.skillPath !== undefined
+    || (typeof process.env.ODAI_SKILL_PATH === "string" && process.env.ODAI_SKILL_PATH.trim() !== "");
+  const bundled = loadSkillBundle(skillPath, {
+    source: explicitSkillPath ? "path" : "bundled",
+    provider: explicitSkillPath ? "odai-explicit-path" : "odai-dsh-runtime",
+  });
+  if (bundled.manifest.runtimeContract !== ODAI_RUNTIME_CONTRACT) {
+    throw new Error(`Odai canonical runtimeContract ${bundled.manifest.runtimeContract} is incompatible with this runtime`);
+  }
+  const baseSelection = Object.freeze({
+    mode: explicitSkillPath ? "path" : "bundled",
+    status: "selected",
+    reasonCode: explicitSkillPath ? "explicit-path" : "bundled-configured",
+    bundle: bundled,
+    rejections: Object.freeze([]),
+  });
 
   ctx.systemPrompt.section({
     name: "odai:canonical-governance",
     order: -20,
-    text: canonicalPrompt(skillPath, skillText),
+    text: canonicalPrompt(baseSelection),
   });
   ctx.systemPrompt.section({
     name: "odai:routing-configuration",
     order: -19,
     text: ROUTING_CONFIG_PROMPT,
   });
+  ctx.systemPrompt.section({
+    name: "odai:skill-source-configuration",
+    order: -18,
+    text: SKILL_SOURCE_CONFIG_PROMPT,
+  });
+
+  const optionalSkillRegistry = () => {
+    try {
+      if (ctx.skills && typeof ctx.skills.get === "function") return ctx.skills;
+    } catch {}
+    try {
+      const service = typeof ctx.get === "function" ? ctx.get("skills") : undefined;
+      return service && typeof service.get === "function" ? service : undefined;
+    } catch {
+      return undefined;
+    }
+  };
+  const selectForAgent = async (agent, context) => {
+    if (explicitSkillPath) return baseSelection;
+    let mode;
+    try {
+      mode = effectiveSkillSource(config.governance.skillConfigPath, config.governance.skillSource);
+    } catch (error) {
+      return Object.freeze({
+        ...baseSelection,
+        mode: "bundled",
+        status: "fallback",
+        reasonCode: "source-config-invalid",
+        detail: error instanceof Error ? error.message : String(error),
+      });
+    }
+    return resolveSkillSelection({
+      mode,
+      bundled,
+      cwd: agent.session?.header?.cwd,
+      scope: context.scope,
+      signal: context.signal,
+      skills: optionalSkillRegistry(),
+    });
+  };
+  ctx.on("system-prompt/assemble", async (assembly, context, next) => {
+    const downstream = await next();
+    const agent = context.agent;
+    if (!agent) return downstream;
+    const selection = await selectSharedSkillForTurn(agent, () => selectForAgent(agent, context));
+    const turn = currentAgentTurn(agent);
+    const selectionEvidence = {
+      ...(turn === undefined ? {} : { turn }),
+      requestedMode: selection.mode,
+      status: selection.status,
+      reasonCode: selection.reasonCode,
+      effectiveSource: selection.bundle.source,
+      skillVersion: selection.bundle.manifest.skillVersion,
+      runtimeContract: selection.bundle.manifest.runtimeContract,
+      digest: selection.bundle.digest,
+      rejections: selection.rejections.map(({ source, reasonCode }) => ({ source, reasonCode })),
+    };
+    if (!hasSessionEvent(agent, "odai/skill-selected", (data) => data?.turn === turn && data?.digest === selection.bundle.digest)) {
+      appendEvent(agent, "odai/skill-selected", selectionEvidence);
+    }
+    if (selection.status === "fallback") {
+      logger.warn(`Odai skill source ${selection.mode} fell back to bundled governance (${selection.reasonCode})`);
+    }
+    return {
+      ...downstream,
+      sections: downstream.sections.map((section) => section.name === "odai:canonical-governance"
+        ? { ...section, text: canonicalPrompt(selection) }
+        : section),
+    };
+  });
 
   const routeProtections = new WeakMap();
   const controllerUpgrades = new WeakMap();
@@ -354,6 +489,16 @@ export function apply(ctx, rawConfig) {
       appendEvent(agent, "odai/routing-configured", data);
     },
   }));
+  ctx.tools.register(createSkillSourceConfigTool(
+    config.governance.skillConfigPath,
+    config.governance.skillSource,
+    {
+      explicitPath: explicitSkillPath,
+      onConfigured(agent, data) {
+        appendEvent(agent, "odai/skill-source-configured", data);
+      },
+    },
+  ));
   ctx.tools.guard((execution) => childGuard(execution) ?? routeProtectionGuard(execution));
 
   ctx.on("tools/result", (execution, result) => {
@@ -423,7 +568,7 @@ export function apply(ctx, rawConfig) {
       if (routed.has(routeKey)) return downstream;
       routed.add(routeKey);
 
-      const taskText = extractLatestUserText(downstream.messages).slice(0, config.routing.maxInputChars);
+      const taskText = extractRoutingText(downstream.messages, agent?.session?.events).slice(0, config.routing.maxInputChars);
       const decision = decideRoute({ text: taskText });
       const routeRole = decision.targetRole ?? decision.role;
       appendEvent(agent, "odai/route-decided", {
@@ -520,7 +665,7 @@ export function apply(ctx, rawConfig) {
             provider: config.routing.provider,
             decision: delegationDecision,
             taskText,
-            roleContract: roleContracts[routeRole],
+            roleContract: (sharedSkillSelection(agent, turn)?.bundle ?? bundled).roleContracts[routeRole],
             agent,
             signal,
             roleRoute,
@@ -577,7 +722,7 @@ export function apply(ctx, rawConfig) {
     }, { prepend: true });
   }
 
-  logger.info(`loaded canonical governance from ${skillPath}; routing=${config.routing.mode}`);
+  logger.info(`loaded canonical governance ${bundled.manifest.skillVersion} from ${skillPath}; skillSource=${explicitSkillPath ? "path" : config.governance.skillSource}; routing=${config.routing.mode}`);
 }
 
 function isSubagentSession(agent) {

package/preset/odai/runtime/router.mjs

@@ -60,6 +60,16 @@ const IRREVERSIBLE_ACTION_PATTERNS = [
   /\b(?:delete|drop|clear|migrate|deploy|release|disable)\b/iu,
 ];
 
+const CONTINUATION_PATTERNS = [
+  /(?:继续|接着|进一步|深入|再(?:判断|分析|评估|检查|处理)|按(?:照)?(?:刚才|上面|上述|前面|这个|该)|那就|就按)/iu,
+  /\b(?:continue|proceed|go ahead|follow up|dig deeper|based on (?:that|the previous|the above))\b/iu,
+];
+
+const LOW_RISK_TRANSFORM_PATTERNS = [
+  /(?:重述|总结|概括|压缩|翻译|改写|润色|格式化|解释(?:一下)?)/iu,
+  /\b(?:restate|summari[sz]e|translate|shorten|rewrite|format|explain)\b/iu,
+];
+
 function matchesAny(text, patterns) {
   return patterns.some((pattern) => pattern.test(text));
 }
@@ -72,6 +82,48 @@ function stripQuotedMaterial(text) {
     .replace(/“[^”\n]*”|‘[^’\n]*’|「[^」\n]*」|『[^』\n]*』|《[^》\n]*》|"[^"\n]*"/gu, " ");
 }
 
+function hasContextualPlannerGap(text) {
+  return matchesAny(text, RISK_PATTERNS)
+    && matchesAny(text, UNVERIFIED_CAUSAL_PATTERNS)
+    && matchesAny(text, CONCRETE_CHANGE_PATTERNS)
+    && (matchesAny(text, SPECIFIC_PARAMETER_PATTERNS)
+      || matchesAny(text, URGENCY_PATTERNS)
+      || matchesAny(text, IRREVERSIBLE_ACTION_PATTERNS));
+}
+
+function isLowRiskTransform(text) {
+  return matchesAny(stripQuotedMaterial(text), LOW_RISK_TRANSFORM_PATTERNS);
+}
+
+function genuineUserText(message) {
+  if (message?.role !== "user" || message?.source?.kind !== "user" || !Array.isArray(message.content)) return "";
+  return message.content
+    .filter((block) => block?.type === "text" && typeof block.text === "string")
+    .map((block) => block.text)
+    .join("\n")
+    .trim();
+}
+
+function genuineUserTexts(messages, sessionEvents = []) {
+  const candidates = [
+    ...(Array.isArray(messages) ? [...messages].reverse() : []),
+    ...(Array.isArray(sessionEvents)
+      ? [...sessionEvents].reverse()
+        .filter((event) => event?.type === "user/message")
+        .map((event) => event.data)
+      : []),
+  ];
+  const seen = new Set();
+  const texts = [];
+  for (const message of candidates) {
+    const text = genuineUserText(message);
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    texts.push(text);
+  }
+  return texts;
+}
+
 function route(role, reasonCode, reason, signals, action = role === "controller" ? "direct" : "delegate", targetRole) {
   return Object.freeze({
     role,
@@ -137,11 +189,11 @@ export function decideRoute(input = {}) {
     );
   }
 
-  const hasContextualPlannerGap = riskPresent
+  const contextualPlannerGap = riskPresent
     && unverifiedCausalClaim
     && concreteChangeRequest
     && (specificOperationalParameter || urgencyPressure || irreversibleAction);
-  if (hasContextualPlannerGap) {
+  if (contextualPlannerGap) {
     return route(
       "controller",
       HIGH_IMPACT_PLANNER_REASON,
@@ -162,23 +214,29 @@ export function decideRoute(input = {}) {
 }
 
 export function extractLatestUserText(messages) {
-  if (!Array.isArray(messages)) return "";
-
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message?.role !== "user") continue;
-    if (message?.source?.kind !== "user") continue;
-    if (!Array.isArray(message.content)) continue;
-
-    const text = message.content
-      .filter((block) => block?.type === "text" && typeof block.text === "string")
-      .map((block) => block.text)
-      .join("\n")
-      .trim();
-    if (text) return text;
+  return genuineUserTexts(messages)[0] ?? "";
+}
+
+export function extractRoutingText(messages, sessionEvents) {
+  const texts = genuineUserTexts(messages, sessionEvents);
+  const latest = texts[0] ?? "";
+  if (!latest
+    || hasContextualPlannerGap(latest)
+    || !matchesAny(stripQuotedMaterial(latest), CONTINUATION_PATTERNS)
+    || isLowRiskTransform(latest)) {
+    return latest;
   }
 
-  return "";
+  let referencedHighImpact;
+  for (const text of texts.slice(1)) {
+    if (hasContextualPlannerGap(text)) {
+      referencedHighImpact = text;
+      break;
+    }
+    if (!isLowRiskTransform(text)) break;
+  }
+  if (!referencedHighImpact) return latest;
+  return `${latest}\n\nReferenced earlier high-impact user context:\n${referencedHighImpact}`;
 }
 
 export function requiresFailClosedProtection(decision) {
@@ -283,6 +341,7 @@ export function renderDelegationPrompt(decision, taskText, roleContract) {
     `You are the odai ${decision.role}.`,
     roleContract.trim(),
     "Runtime boundary: do not edit files, run shell commands, ask the user, or delegate further. The controller owns all final decisions and delivery.",
+    "Context boundary: this is a bounded task and evidence packet, not an inherited controller transcript. Use only the supplied contract, task, evidence, and source pointers; do not request or reconstruct the controller's full history.",
     "",
     "Task:",
     taskText,