odai-dsh-agent 0.2.56 → 0.2.57

package/preset/odai/skills/odai-orchestration/scripts/install-routing.mjs

@@ -20,13 +20,14 @@ const scriptDir = path.dirname(fileURLToPath(import.meta.url));
 const builder = path.join(scriptDir, "build-routing.mjs");
 const manifestName = "odai-routing.json";
 const requiredRoles = ["controller", "planner", "reviewer"];
-const configurableRoles = [...requiredRoles, "researcher", "frontend", "creative"];
+const configurableRoles = [...requiredRoles, "researcher", "frontend", "creative", "writer"];
 const args = parseArgs(process.argv.slice(2));
 const roles = Object.freeze([
   ...requiredRoles,
   ...(args.researcherModel ? ["researcher"] : []),
   ...(args.frontendModel ? ["frontend"] : []),
   ...(args.creativeModel ? ["creative"] : []),
+  ...(args.writerModel ? ["writer"] : []),
 ]);
 const retiredByHost = {
   codex: [
@@ -41,11 +42,12 @@ const retiredByHost = {
 
 if (args.help) { printHelp(); process.exit(0); }
 if (!new Set(["codex", "claude", "copilot"]).has(args.host)) fail(`不支持的 host：${args.host || "(missing)"}`);
+if ((args.namedDispatch || args.leadMode) && !["claude", "codex"].includes(args.host)) fail("--named-dispatch / --lead-mode requires claude or codex");
 if (!new Set(["project", "user"]).has(args.scope)) fail(`不支持的 scope：${args.scope}`);
 for (const role of configurableRoles) {
   if (!args[`${role}Cli`]) continue;
-  if (args.host !== "claude") fail(`--${role}-cli is only supported with --host claude`);
-  if (!["codex", "antigravity", "grok"].includes(args[`${role}Cli`])) fail(`--${role}-cli must be codex, antigravity, or grok`);
+  if (!["claude", "codex"].includes(args.host)) fail(`--${role}-cli requires claude or codex`);
+  if (!(args.host === "codex" ? ["claude", "antigravity", "grok"] : ["codex", "antigravity", "grok"]).includes(args[`${role}Cli`])) fail(`--${role}-cli must be ${args.host === "codex" ? "claude" : "codex"}, antigravity, or grok`);
   if (!args[`${role}Model`]) fail(`--${role}-cli 需要同时提供 --${role}-model`);
 }
 if (!args.yes) fail("安装、更新或卸载会持久化宿主配置；取得用户授权后传入 --yes");
@@ -72,6 +74,7 @@ function main() {
   for (const role of requiredRoles) if (!args[`${role}Model`]) fail(`缺少 --${role}-model`);
   if (args.researcherEffort && !args.researcherModel) fail("--researcher-effort 需要同时提供 --researcher-model");
   if (args.frontendEffort && !args.frontendModel) fail("--frontend-effort 需要同时提供 --frontend-model");
+  if (args.writerEffort && !args.writerModel) fail("--writer-effort 需要同时提供 --writer-model");
   if (args.creativeEffort && !args.creativeModel) fail("--creative-effort 需要同时提供 --creative-model");
   if (!existsSync(builder)) fail(`缺少路由生成器：${builder}`);
 
@@ -128,10 +131,13 @@ function main() {
 
 function buildAdapter(outputRoot, root) {
   const command = [builder, "--host", args.host, "--out", outputRoot];
+  if (args.namedDispatch) command.push("--named-dispatch");
+  if (args.leadMode) command.push("--lead-mode");
   if (args.governanceRoot) command.push("--governance-root", args.governanceRoot);
   for (const role of roles) {
     command.push(`--${role}-model`, args[`${role}Model`]);
     if (args[`${role}Effort`]) command.push(`--${role}-effort`, args[`${role}Effort`]);
+    if (args[`${role}Session`]) command.push(`--${role}-session`, args[`${role}Session`]);
     if (args[`${role}Cli`]) command.push(`--${role}-cli`, args[`${role}Cli`]);
   }
   if (args.host === "codex") command.push("--verifier-command", `node ${JSON.stringify(path.join(root, "odai-verify-routing.mjs"))}`);
@@ -151,6 +157,11 @@ function collectGeneratedFiles(root, layoutValue) {
     if (args.host === "claude" && args.scope === "user" && targetRelative === "agents/odai-controller.md") {
       content = Buffer.from(content.toString("utf8").replaceAll("node .claude/odai-run-role.mjs", claudeRunnerCommand()));
     }
+    if (args.host === "codex" && targetRelative === "named-dispatch-plugin/hooks/hooks.json") {
+      const value = JSON.parse(content);
+      for (const entries of Object.values(value.hooks)) for (const entry of entries) for (const hook of entry.hooks) hook.command = `node '${path.join(configRoot, "odai-route-hook.mjs").replaceAll("'", "'\\''")}'`;
+      content = Buffer.from(JSON.stringify(value, null, 2) + "\n");
+    }
     result.set(targetRelative, content);
   }
   return result;
@@ -176,19 +187,19 @@ function originalFileRecord(file) {
 }
 
 function mergeCodexConfig(original, generated) {
-  if (/^\s*\[agents\.odai_(?:researcher|planner|executor|reviewer|frontend|creative)\]\s*$/m.test(original)) {
+  if (/^\s*\[agents\.odai_(?:researcher|planner|executor|reviewer|frontend|creative|writer)\]\s*$/m.test(original)) {
     fail("既有 Codex 配置已声明 odai 角色但不受当前安装清单管理");
   }
   const generatedFeatures = generated.search(/^\s*\[features\]\s*$/m);
   if (generatedFeatures < 0) fail("生成的 Codex 配置缺少 [features]");
   const generatedAgents = generated.search(/^\s*\[agents\.odai_/m);
-  if (generatedAgents < 0) fail("生成的 Codex 配置缺少 odai 角色注册");
+
   const existingInstructions = topLevelTomlString(original, "developer_instructions");
   const generatedController = generated.slice(0, generatedFeatures).trim();
   const controller = existingInstructions
     ? appendDeveloperInstructions(generatedController, existingInstructions)
     : generatedController;
-  const agents = generated.slice(generatedAgents).trim();
+  const agents = generatedAgents < 0 ? "" : generated.slice(generatedAgents).trim();
   let preserved = removeTopLevelCodexKeys(original, new Set(["model", "model_reasoning_effort", "developer_instructions"]));
   preserved = setFeatureFlag(preserved, "multi_agent", "true");
   return [controller, preserved.trim(), agents].filter(Boolean).join("\n\n") + "\n";
@@ -246,6 +257,7 @@ function setFeatureFlag(source, name, value) {
   return lines.join("\n");
 }
 
+
 function hostLayout(host, scope) {
   if (host === "codex") {
     const researcherFiles = [
@@ -258,6 +270,8 @@ function hostLayout(host, scope) {
       [".codex/role-contracts/odai-frontend.md", "role-contracts/odai-frontend.md"],
     ];
     const frontend = roles.includes("frontend") ? frontendFiles : [];
+    const writerFiles = [[".codex/agents/odai-writer.toml", "agents/odai-writer.toml"], [".codex/role-contracts/odai-writer.md", "role-contracts/odai-writer.md"]];
+    const writer = roles.includes("writer") ? writerFiles : [];
     const creativeFiles = [
       [".codex/agents/odai-creative.toml", "agents/odai-creative.toml"],
       [".codex/role-contracts/odai-creative.md", "role-contracts/odai-creative.md"],
@@ -274,10 +288,13 @@ function hostLayout(host, scope) {
       ...researcher,
       ...frontend,
       ...creative,
+      ...writer,
     ];
-    const generatedFiles = common;
+    common.push(...namedFiles(host).map(file => [`.codex/${file}`, file]));
+    const generatedFiles = common.filter(([source]) => !roles.some(role => args[`${role}Cli`] && source === `.codex/agents/odai-${role}.toml`));
+    if (roles.some(role => args[`${role}Cli`])) generatedFiles.push([".codex/odai-local-cli.mjs", "odai-local-cli.mjs"]);
     return {
-      knownFiles: [...new Set([...common, ...researcherFiles, ...frontendFiles, ...creativeFiles].map(([, target]) => target)), "hooks.json", "odai-route-hook.mjs", "odai-run-routing.mjs", "agents/odai-executor.toml", "role-contracts/odai-executor.md"],
+      knownFiles: [...namedFiles(host, true), "odai-local-cli.mjs", ...new Set([...common, ...researcherFiles, ...frontendFiles, ...creativeFiles, ...writerFiles].map(([, target]) => target)), "hooks.json", "odai-route-hook.mjs", "odai-run-routing.mjs", "agents/odai-executor.toml", "role-contracts/odai-executor.md"],
       managedFiles: generatedFiles.map(([, target]) => target),
       generatedFiles,
       settings: null,
@@ -288,9 +305,10 @@ function hostLayout(host, scope) {
     const local = roles.filter(role => args[`${role}Cli`]);
     const managedFiles = roles.map(role => `${args[`${role}Cli`] ? "role-contracts" : "agents"}/odai-${role}.md`);
     if (local.length) managedFiles.push(...executors);
+    managedFiles.push(...namedFiles(host));
     return {
       knownFiles: [...configurableRoles.map(role => `agents/odai-${role}.md`),
-        ...configurableRoles.filter(role => role !== "controller").map(role => `role-contracts/odai-${role}.md`), ...executors],
+        ...configurableRoles.filter(role => role !== "controller").map(role => `role-contracts/odai-${role}.md`), ...executors, ...namedFiles(host, true)],
       managedFiles,
       generatedFiles: managedFiles.map(file => [`.claude/${file}`, file]),
       settings: { file: scope === "project" ? "settings.local.json" : "settings.json", key: "agent", value: "odai-controller",
@@ -314,6 +332,7 @@ function planSettings(root, layoutValue, manifest) {
   if (manifest) {
     if (!installed || installed.file !== spec.file || installed.key !== spec.key || installed.installed !== spec.value) fail("旧路由缺少可恢复的宿主设置记录");
     if (current[spec.key] !== spec.value) fail(`宿主设置 ${spec.key} 已被外部修改`);
+    restoreNamedHooks(current, installed.namedHooks);
     restorePermission(current, installed.permission);
   } else {
     const present = Object.hasOwn(current, spec.key);
@@ -321,6 +340,14 @@ function planSettings(root, layoutValue, manifest) {
     installed = { file: spec.file, key: spec.key, installed: spec.value, fileExistedBefore: existsSync(file), previous: { present, value: present ? current[spec.key] : null } };
   }
   const record = { ...installed };
+  delete record.namedHooks;
+  if (args.namedDispatch || args.leadMode) {
+    const command = `node '${path.join(root, "odai-route-hook.mjs").replaceAll("'", "'\\''")}'`;
+    const entries = Object.fromEntries(["UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"].map(event => [event, { matcher: "*", hooks: [{ type: "command", command, timeout: 10 }] }]));
+    record.namedHooks = entries;
+    current.hooks ||= {};
+    for (const [event, entry] of Object.entries(entries)) current.hooks[event] = [...(current.hooks[event] || []), entry];
+  }
   delete record.permission;
   if (spec.permission) {
     const permissionsPresent = Object.hasOwn(current, "permissions");
@@ -388,7 +415,9 @@ function assertManagedState(root, layoutValue, manifest) {
       || installedSetting.installed !== expectedSetting.value) {
       fail("旧路由缺少可恢复的宿主设置记录");
     }
-    assertPermission(readJsonObject(path.join(root, installedSetting.file)), installedSetting.permission);
+    const currentSettings = readJsonObject(path.join(root, installedSetting.file));
+    assertNamedHooks(currentSettings, installedSetting.namedHooks);
+    assertPermission(currentSettings, installedSetting.permission);
   } else if (installedSetting) {
     fail("旧路由包含当前宿主不支持的设置记录");
   }
@@ -415,7 +444,7 @@ function removeObsolete(root, manifest, desiredFiles) {
   if (!manifest) return;
   const desired = new Set(desiredFiles.keys());
   const obsolete = new Set([
-    ...layout.retiredFiles.filter((relative) => manifest.files?.[relative]),
+    ...layout.retiredFiles.filter((relative) => manifest.files?.[relative] && !desired.has(relative)),
     ...Object.keys(manifest.files || {}).filter((relative) => !desired.has(relative)),
   ]);
   for (const relative of obsolete) if (existsSync(path.join(root, relative))) unlinkSync(path.join(root, relative));
@@ -461,6 +490,7 @@ function uninstall(root, manifestPathValue, manifest) {
 function planSettingRestore(root, spec) {
   const current = readJsonObject(path.join(root, spec.file));
   if (current[spec.key] !== spec.installed) fail(`宿主设置 ${spec.key} 已被外部修改，拒绝删除`);
+  restoreNamedHooks(current, spec.namedHooks);
   restorePermission(current, spec.permission);
   if (spec.previous?.present) current[spec.key] = spec.previous.value; else delete current[spec.key];
   return {
@@ -542,12 +572,15 @@ function parseArgs(values) {
   const fields = new Map([["--host", "host"], ["--scope", "scope"], ["--target", "target"], ["--governance-root", "governanceRoot"]]);
   for (const role of configurableRoles) {
     fields.set(`--${role}-model`, `${role}Model`); fields.set(`--${role}-effort`, `${role}Effort`);
+    if (role !== "controller") fields.set(`--${role}-session`, `${role}Session`);
     if (role !== "controller") fields.set(`--${role}-cli`, `${role}Cli`);
   }
   for (let index = 0; index < values.length; index += 1) {
     const value = values[index];
     if (value === "--help" || value === "-h") result.help = true;
     else if (value === "--uninstall") result.uninstall = true;
+    else if (value === "--lead-mode") result.leadMode = true;
+    else if (value === "--named-dispatch") result.namedDispatch = true;
     else if (value === "--yes") result.yes = true;
     else if (fields.has(value)) { const next = values[++index] || ""; if (!next || next.startsWith("--")) fail(`${value} 需要一个值`); result[fields.get(value)] = next; }
     else fail(`未知参数：${value}`);
@@ -555,20 +588,38 @@ function parseArgs(values) {
   return result;
 }
 
-function hasMappingArgs(value) { return configurableRoles.some((role) => value[`${role}Model`] || value[`${role}Effort`] || value[`${role}Cli`]); }
+function hasMappingArgs(value) { return configurableRoles.some((role) => value[`${role}Model`] || value[`${role}Effort`] || value[`${role}Cli`] || value[`${role}Session`]); }
 function printHelp() {
   console.log(`由 odai 在取得用户授权后安装、更新或卸载宿主路由。
 
 Usage:
   node skills/odai-orchestration/scripts/install-routing.mjs --host <codex|claude|copilot> --scope <project|user> [--target <path>] \\
     --controller-model <model> --planner-model <model> --reviewer-model <model> \\
-    [--researcher-model <model>] [--frontend-model <model>] [--creative-model <model>] [--<role>-effort <effort>] [--governance-root <path>] --yes
-  Claude Code only: [--<role>-cli <codex|antigravity|grok>] (non-controller roles)
+    [--researcher-model <model>] [--frontend-model <model>] [--creative-model <model>] [--writer-model <model>] [--<role>-effort <effort>] [--governance-root <path>] --yes
+  Claude: [--<role>-cli <codex|antigravity|grok>]; Codex: [--<role>-cli <claude|antigravity|grok>]\n  [--<role>-session <fresh|continue>] (non-controller roles)\n  [--named-dispatch] [--lead-mode] (Claude / Codex only)
 
   node skills/odai-orchestration/scripts/install-routing.mjs --host <codex|claude|copilot> --scope <project|user> [--target <path>] --uninstall --yes
 
-安装后用户只需正常使用 odai。总控是唯一持续任务线程并负责实施整合；planner、reviewer 以及可选 researcher、frontend、creative 只在能改变结果时启动。researcher、frontend 与 creative 映射默认不配置。更新会安全移除旧版 advisor、implementer、worker、executor 和 stage runner 托管文件。`);
+安装后用户只需正常使用 odai。总控是唯一持续任务线程并负责实施整合；planner、reviewer 以及可选 researcher、frontend、creative、writer 只在能改变结果时启动。researcher、frontend、creative 与 writer 映射默认不配置。更新会安全移除旧版 advisor、implementer、worker、executor 和 stage runner 托管文件。`);
 }
 
 function returnResult(value) { process.stdout.write(`${JSON.stringify(value, null, 2)}\n`); }
 function fail(message) { throw new Error(message); }
+
+function namedFiles(host, all = false) {
+  if (!all && !args.namedDispatch && !args.leadMode) return [];
+  return ["odai-route-hook.mjs", "recognize-routing.mjs", "odai-named-dispatch.json", ...(host === "codex" ? [".agents/plugins/marketplace.json", "named-dispatch-plugin/.codex-plugin/plugin.json", "named-dispatch-plugin/hooks/hooks.json"] : [])];
+}
+function assertNamedHooks(current, entries) {
+  for (const [event, entry] of Object.entries(entries || {})) {
+    if (!(current.hooks?.[event] || []).some(value => JSON.stringify(value) === JSON.stringify(entry))) fail(`路由 Hook 已漂移：${event}`);
+  }
+}
+function restoreNamedHooks(current, entries) {
+  assertNamedHooks(current, entries);
+  for (const [event, entry] of Object.entries(entries || {})) {
+    current.hooks[event] = current.hooks[event].filter(value => JSON.stringify(value) !== JSON.stringify(entry));
+    if (!current.hooks[event].length) delete current.hooks[event];
+  }
+  if (current.hooks && !Object.keys(current.hooks).length) delete current.hooks;
+}

package/preset/odai/skills/odai-orchestration/scripts/local-cli.d.mts

@@ -7,6 +7,7 @@ export interface LocalCliRoute {
   /** Validated by the selected CLI adapter. */
   reasoningEffort?: string;
   timeoutSeconds?: number;
+  session?: "fresh" | "continue";
   provider?: never;
   maxTokens?: never;
 }
@@ -31,6 +32,8 @@ export interface LocalCliParsedResult {
   actualReasoningEffort?: string;
   sessionId?: string;
   deniedActionsCount?: number;
+  boundaryStatus?: "boundary-violation";
+  boundaryTools?: string[];
 }
 
 export interface LocalCliExecutionResult extends Omit<LocalCliParsedResult, "status"> {
@@ -45,6 +48,7 @@ export interface ExecuteLocalCliOptions {
   prompt: string;
   cwd: string;
   signal?: AbortSignal;
+  resumeSessionId?: string;
   env?: NodeJS.ProcessEnv;
   /** Test seam. Injected spawns use child.kill unless killProcess is also supplied. */
   spawnProcess?: typeof spawn;
@@ -57,6 +61,8 @@ export interface ExecuteLocalCliOptions {
 }
 
 export interface LocalCliContext {
+  sessionId?: string;
+  resumeSessionId?: string;
   cwd?: string;
   prompt?: string;
   promptFile?: string;
@@ -73,3 +79,5 @@ export function parseLocalCliResult(stdout: string, requestedRoute: string | Loc
  * the direct child; process-tree cleanup on Windows is not verified.
  */
 export function executeLocalCli(options: ExecuteLocalCliOptions): Promise<LocalCliExecutionResult>;
+
+export const AGY_READ_ONLY_TOOLS: readonly string[];

package/preset/odai/skills/odai-orchestration/scripts/local-cli.mjs

@@ -1,9 +1,10 @@
+import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { chmodSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 const ALIASES = new Set(["opus", "sonnet", "haiku", "fable"]);
-const ROUTE_FIELDS = new Set(["backend", "cli", "model", "reasoningEffort", "timeoutSeconds"]);
+const ROUTE_FIELDS = new Set(["backend", "cli", "model", "reasoningEffort", "timeoutSeconds", "session"]);
 const DEFAULT_TIMEOUT_SECONDS = 1200;
 const MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
 const STDERR_BYTES = 8192;
@@ -29,28 +30,36 @@ export function validateLocalCliRoute(value) {
   if (value.reasoningEffort !== undefined && (typeof value.reasoningEffort !== "string" || /[^a-z]/.test(value.reasoningEffort) || !ADAPTERS[value.cli].effort.test(value.reasoningEffort))) {
     throw new TypeError(`Invalid ${value.cli} reasoningEffort`);
   }
+  if (value.session !== undefined && !["fresh", "continue"].includes(value.session)) throw new TypeError("session must be fresh or continue");
+  if (value.session === "continue" && !ADAPTERS[value.cli].continuation) throw new TypeError(`${value.cli} 暂不支持会话续接`);
   const timeoutSeconds = value.timeoutSeconds;
   if (timeoutSeconds !== undefined && (!Number.isInteger(timeoutSeconds) || timeoutSeconds <= 0 || timeoutSeconds > 7200)) {
     throw new TypeError("local-cli timeoutSeconds must be an integer from 1 to 7200");
   }
   return {
     backend: "local-cli", cli: value.cli, model: value.model,
+    ...(value.session !== undefined ? { session: value.session } : {}),
     ...(value.reasoningEffort !== undefined ? { reasoningEffort: value.reasoningEffort } : {}),
     ...(timeoutSeconds !== undefined ? { timeoutSeconds } : {}),
   };
 }
 
-const AGY_READ_BOUNDARY = "\n\n读文件只用 view_file、grep_search、list_dir、find_by_name；命令行不可用，会被拒绝。";
+export const AGY_READ_ONLY_TOOLS = Object.freeze(["read_file", "search_web", "ask_question", "manage_task", "view_file", "grep_search", "list_dir", "find_by_name"]);
+const AGY_READ_BOUNDARY = "\n\n只用只读工具读取任务包中已给出路径的文件（例如 read_file，旧版本叫 view_file）。不要列目录、搜索文件、执行命令、写入或编辑文件；这些动作会被拒绝，并使本次调用作废。需要但未给出的文件，请在回交中列明所需文件，不要自行尝试。";
 const effortArgs = (route) => route.reasoningEffort ? ["--effort", route.reasoningEffort] : [];
 const ADAPTERS = Object.freeze({
   claude: {
+    continuation: true,
     effort: /^(low|medium|high|xhigh|max)$/,
     command: "claude", override: "ODAI_CLAUDE_COMMAND", input: "stdin",
-    args: (route) => ["-p", "--output-format", "json", "--model", route.model, ...effortArgs(route),
-      "--tools", "Read,Glob,Grep", "--permission-mode", "dontAsk", "--no-session-persistence"],
+    args: (route, { sessionId, resumeSessionId }) => ["-p", "--output-format", "json", "--model", route.model, ...effortArgs(route),
+      "--tools", "Read,Glob,Grep", "--permission-mode", "dontAsk", ...(route.session === "continue"
+        ? [resumeSessionId ? "--resume" : "--session-id", resumeSessionId || sessionId]
+        : ["--no-session-persistence"])],
     parse: (stdout, route) => parseClaudeResult(stdout, route.model),
   },
   codex: {
+    continuation: false,
     effort: /^[a-z]+$/,
     command: "codex", override: "ODAI_CODEX_COMMAND", input: "stdin",
     args: (route, { cwd }) => ["exec", "--json", "--model", route.model,
@@ -59,18 +68,20 @@ const ADAPTERS = Object.freeze({
     parse: parseCodexResult,
   },
   antigravity: {
+    continuation: true,
     effort: /^(low|medium|high)$/,
     command: "agy", override: "ODAI_AGY_COMMAND", input: "argv",
-    args: (route, { prompt }) => {
+    args: (route, { prompt, resumeSessionId }) => {
       if (typeof prompt !== "string") throw new TypeError("antigravity requires a prompt");
       const input = prompt + AGY_READ_BOUNDARY;
       if (Buffer.byteLength(input, "utf8") > 256 * 1024) throw new TypeError("antigravity prompt exceeds 256 KiB (including read-only instructions)");
-      return ["-p", input, "--output-format", "stream-json", "--mode", "plan", "--disable-slash-commands", "--model", route.model,
+      return [...(resumeSessionId ? ["--conversation", resumeSessionId] : []), "-p", input, "--output-format", "stream-json", "--mode", "plan", "--disable-slash-commands", "--model", route.model,
         ...effortArgs(route), "--print-timeout", `${route.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS}s`];
     },
     parse: parseAntigravityResult,
   },
   grok: {
+    continuation: false,
     effort: /^(none|minimal|low|medium|high|xhigh|max)$/,
     command: "grok", override: "ODAI_GROK_COMMAND", input: "file",
     args: (route, { cwd, promptFile }) => {
@@ -89,6 +100,8 @@ export function buildLocalCliInvocation(route, env = process.env, context = {})
     throw new TypeError(`${normalized.cli} requires cwd`);
   }
   const adapter = ADAPTERS[normalized.cli];
+  if (context.resumeSessionId !== undefined && (normalized.session !== "continue" || typeof context.resumeSessionId !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9-]*$/.test(context.resumeSessionId))) throw new TypeError("Invalid resume session ID");
+  if (normalized.cli === "claude" && normalized.session === "continue" && !context.resumeSessionId && !context.sessionId) throw new TypeError("Claude continuation requires a new session ID");
   return { command: env[adapter.override] || adapter.command, args: adapter.args(normalized, context) };
 }
 
@@ -214,6 +227,8 @@ function parseCodexResult(stdout, route, { cwd, env }) {
 
 function parseAntigravityResult(stdout, route) {
   const events = jsonLines(stdout);
+  const violations = [...new Set(events.filter(event => event.event === "step_update" && event.step_update?.step_type === "tool" && event.step_update?.state === "DONE" && !AGY_READ_ONLY_TOOLS.includes(event.step_update.tool_name)).map(event => String(event.step_update.tool_name ?? "<missing>")))];
+  if (violations.length) return { ...emptyResult("error", `boundary-violation: ${violations.join(", ")}；agy 的权限设置允许了写类工具，请检查 agy 设置里的 permissions.allow。执行后检查不能撤销已发生的动作。`), boundaryStatus: "boundary-violation", boundaryTools: violations };
   const init = events.find((event) => event.event === "init");
   const payload = events.findLast((event) => event.event === "result")?.result;
   if (!isRecord(payload)) return emptyResult("error", "Antigravity returned no result event");
@@ -285,10 +300,11 @@ export function parseLocalCliResult(stdout, requestedRoute, context = {}) {
 
 /** Executes only the target CLI. Host routing and fallback policy belong to callers. */
 export async function executeLocalCli({
-  route, prompt, cwd, signal, env = process.env, spawnProcess = spawn, killProcess,
+  route, prompt, cwd, signal, resumeSessionId, env = process.env, spawnProcess = spawn, killProcess,
   killGraceMs = 1000, maxOutputBytes = MAX_OUTPUT_BYTES,
 }) {
   const normalized = validateLocalCliRoute(route);
+  const sessionId = normalized.session === "continue" && normalized.cli === "claude" ? resumeSessionId || randomUUID() : undefined;
   if (typeof prompt !== "string") throw new TypeError("local-cli prompt must be a string");
   if (typeof cwd !== "string" || !cwd) throw new TypeError("local-cli cwd must be a non-empty string");
   if (!Number.isSafeInteger(killGraceMs) || killGraceMs < 0) throw new TypeError("killGraceMs must be a non-negative safe integer");
@@ -313,7 +329,7 @@ export async function executeLocalCli({
       promptFile = join(temporary, "prompt.txt");
       writeFileSync(promptFile, prompt, { encoding: "utf8", mode: 0o600, flag: "wx" });
     }
-    const invocation = buildLocalCliInvocation(normalized, env, { prompt, cwd, promptFile });
+    const invocation = buildLocalCliInvocation(normalized, env, { prompt, cwd, promptFile, sessionId, resumeSessionId });
     return await new Promise((resolve) => {
       let child;
       let settled = false;
@@ -396,7 +412,7 @@ export async function executeLocalCli({
           finish(emptyResult("error", `${normalized.cli} exited ${terminationSignal ? `with signal ${terminationSignal}` : `with code ${code}`}${details ? `: ${details}` : ""}`));
           return;
         }
-        finish(parseLocalCliResult(Buffer.concat(stdout).toString("utf8"), normalized, { cwd, env }));
+        finish({ ...parseLocalCliResult(Buffer.concat(stdout).toString("utf8"), normalized, { cwd, env }), ...(sessionId ? { sessionId } : {}) });
       });
       child.stdin.on("error", (error) => {
         // Early CLI failure often closes stdin first; close still supplies its stderr and exit code.

package/preset/odai/skills/odai-orchestration/scripts/recognize-routing.d.mts

@@ -0,0 +1,6 @@
+export type Responsibility = 'controller' | 'researcher' | 'planner' | 'reviewer' | 'frontend' | 'creative' | 'writer' | 'user';
+export interface ModelRoute { backend?: string; cli?: string; provider?: string; model: string }
+export interface NamedRequest { responsibility: Responsibility; timing: 'start' | 'completion'; excerpt: string; name: string; canceled?: boolean; issue?: 'unconfigured' | 'mapping-mismatch' }
+export function recognizeNamedRequests(text: string, routes: Partial<Record<Responsibility, ModelRoute>>): NamedRequest[];
+export function recognizeLeadSwitch(text: string, routes: Partial<Record<'planner' | 'reviewer', ModelRoute>>): { enabled: boolean; roles: string[]; issue?: string } | undefined;
+export function parseLeadVerdict(text: string): "pass" | "changes-requested" | "invalid";

package/preset/odai/skills/odai-orchestration/scripts/recognize-routing.mjs

@@ -0,0 +1,93 @@
+
+
+
+
+
+
+
+
+
+
+
+// Deliberately bounded grammar: an imperative delegation, never a bare role word.
+export function recognizeNamedRequests(text        , routes                                             )                 {
+  const clean = text.replace(/```[\s\S]*?```|`[^`]*`|“[^”]*”|‘[^’]*’|「[^」]*」|『[^』]*』|"[^"\n]*"|'[^'\n]*'/gu, " ").replace(/^\s*>.*$/gmu, " ");
+  const dynamicNames = Object.values(routes).flatMap(route => route ? [
+    route.backend === "local-cli" ? route.cli : route.provider,
+    /^[a-z]+/iu.exec(route.model)?.[0],
+  ].filter((name)                 => !!name && /^[a-z][a-z0-9_-]*$/iu.test(name)) : []);
+  const escape = (name        )         => name.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const aliases = "Claude|克劳德|opus|sonnet|Gemini|反重力|agy|antigravity|GPT|Codex|Grok|planner|reviewer|researcher|creative|writer|frontend|规划职责|审查职责|研究职责|创意职责|写作职责|前端职责";
+  const names = [...new Set([...aliases.split("|"), ...dynamicNames])].sort((a, b) => b.length - a.length).map(escape).join("|");
+  const directive = new RegExp(`(?:让|交给|请|叫|找|用|have\\s+|let\\s+|ask\\s+|use\\s+)\\s*(${names})(?![a-z0-9_-])|交给\\s*(规划|调查|审查|创意|写作|前端)(?!职责)`, "iu");
+  const bare = new RegExp(`^\\s*(${names})(?![a-z0-9_-])\\s*(?:来|去)?\\s*(?:写|起草|改写|润色|翻译|定方向|审|规划|plan|write|review)`, "iu");
+  const result                 = [];
+  let creativeContext = false;
+  let delegated = false;
+  for (const clause of clean.split(/[，,；;。\n]|\bthen\b/iu)) {
+    if (/(?:以后|今后|from now on).*?(?:都|always)|^\s*(?:configure|配置|设置|映射)\b|(?:规划|审查|写作|前端|创意|调查)\s*用本机|推理档/iu.test(clause)) continue;
+    const match = directive.exec(clause) ?? (delegated ? bare.exec(clause) : null);
+    if (!match || /(?:了吗|过了|不错|怎么样|是否|要不要|能不能|吗|？|\?|last time|already)/iu.test(clause)) continue;
+    const prefix = clause.slice(0, match.index).trim();
+    // A bounded topic is allowed; an enclosing action ("写一下让…的测试") is not.
+    if (!/^(?:(?:先|再|然后|最后|做完|写完|改完|完成后|之后|交付前|麻烦|请你|你|不用|不要|别|无需|不必)\s*)*(?:文案|台词|对白|宣传语|商店页|规划|代码|界面)?\s*$/u.test(prefix)) continue;
+    delegated = true;
+    const name = match[1] ?? match[2] ;
+    const creativeObject = /文案|台词|对白|画面|美术|视觉|宣传|商店页|稿|copy|dialogue|prose/iu.test(clause);
+    let candidates                   = [];
+    if (/规划|计划|出方案|定方案|拆任务|\bplan\b/iu.test(clause)) candidates = ["planner"];
+    else if (/调查|调研|查资料|核实来源|\bresearch\b/iu.test(clause)) candidates = ["researcher"];
+    else if (/定方向|构思|起名|出点子/iu.test(clause)) { candidates = ["creative"]; creativeContext = true; }
+    else if (/界面|前端实现|做\s*UI|frontend/iu.test(clause)) candidates = ["frontend"];
+    else if (/(?:写(?!完|进|到|入|在)|起草|改写|润色|翻译|本地化|\bwrite\b)/iu.test(clause) && creativeObject) candidates = routes.writer ? ["writer", "creative"] : ["creative"];
+    else if (/审|验收|复核|检查|把关|评估|看看|\breview\b/iu.test(clause)) candidates = creativeObject || (creativeContext && !/验收|复核|检查/iu.test(clause)) ? ["creative"] : ["reviewer"];
+    if (!candidates.length && match[2]) candidates = [{ 规划: "planner", 调查: "researcher", 审查: "reviewer", 创意: "creative", 写作: "writer", 前端: "frontend" }[name]                  ];
+    if (!candidates.length) continue;
+    const explicitRole                                 = { planner: "planner", reviewer: "reviewer", researcher: "researcher", creative: "creative", writer: "writer", frontend: "frontend", 规划职责: "planner", 审查职责: "reviewer", 研究职责: "researcher", 创意职责: "creative", 写作职责: "writer", 前端职责: "frontend", 规划: "planner", 调查: "researcher", 审查: "reviewer", 创意: "creative", 写作: "writer", 前端: "frontend" };
+    const role = explicitRole[name.toLowerCase()];
+    const matches = (route                        )          => {
+      if (!route) return false;
+      const value = `${route.backend === "local-cli" ? route.cli : route.provider} ${route.model}`;
+      if (/^(Claude|克劳德|opus|sonnet)$/iu.test(name)) return /claude|anthropic|opus|sonnet/iu.test(value);
+      if (/^(Gemini|反重力|agy|antigravity)$/iu.test(name)) return /antigravity|gemini/iu.test(value);
+      if (/^(GPT|Codex)$/iu.test(name)) return /openai|codex|gpt/iu.test(value);
+      if (/^Grok$/iu.test(name)) return route.backend === "local-cli" && route.cli === "grok";
+      return [route.backend === "local-cli" ? route.cli : route.provider, /^[a-z]+/iu.exec(route.model)?.[0]].some(value => value?.toLowerCase() === name.toLowerCase());
+    };
+    const responsibility = role ?? candidates.find(candidate => matches(routes[candidate])) ?? candidates[0] ;
+    const timing = /先(?:让|请|用|交给|叫|找|规划|审|验收|调研|调查|写|做|定)|\bfirst\b/iu.test(clause) ? "start" : /做完|写完|改完|完成后|之后|最后|交付前|\bafter\b|once done|when done|finally|before delivering/iu.test(clause) ? "completion" : responsibility === "reviewer" ? "completion" : "start";
+    const delegationPrefix = clause.slice(0, match.index + match[0].indexOf(name));
+    const canceled = /(?:不用|不要|别|无需|不必)\s*(?:再)?\s*(?:让|交给|请|叫|找|用)?\s*$|(?:do not|don't)\s+(?:let|have|ask|use)\s*$/iu.test(delegationPrefix);
+    const issue = !routes[responsibility] ? "unconfigured" : !role && !matches(routes[responsibility]) ? "mapping-mismatch" : undefined;
+    if (!result.some(item => item.responsibility === responsibility && item.timing === timing && item.canceled === canceled)) result.push({ responsibility, timing, excerpt: clause.trim(), name, ...(canceled ? { canceled: true } : {}), ...(issue ? { issue } : {}) });
+  }
+  return result;
+}
+
+
+export function recognizeLeadSwitch(text        , routes        )                                                                    {
+  const clean = text.replace(/```[\s\S]*?```|`[^`]*`|“[^”]*”|「[^」]*」|『[^』]*』|‘[^’]*’|"[^"\n]*"|'[^'\n]*'/gu, " ").replace(/^\s*>.*$/gmu, " ");
+  let result;
+  for (const raw of clean.split(/[，,；;。\n]/u)) {
+    const clause = raw.trim();
+    if (/吗|？|\?|是否|能不能|配置|设置|以后|默认|开关|测试/iu.test(clause)) continue;
+    if (/^(?:关闭主导模式|退出主导模式|恢复正常模式|disable lead mode)[！!]?$/iu.test(clause)) result = { enabled: false, roles: [] };
+    else {
+      const direct = /^(?:(?:这个|当前)会话\s*)?(?:开启|打开|启用|开)主导模式[！!]?$/u.test(clause) || /^enable lead mode[！!]?$/iu.test(clause);
+      const named = /^(?:这个|当前)会话由\s*(\S+)\s*主导[！!]?$/u.exec(clause);
+      if (!direct && !named) continue;
+      let roles = Object.keys(routes).filter(role => routes[role                ]);
+      if (named) roles = roles.filter(role => !recognizeNamedRequests(`让 ${named[1]} ${role === "planner" ? "规划" : "验收"}`, routes).every(request => request.issue || request.responsibility !== role));
+      result = { enabled: roles.length > 0, roles, ...(roles.length ? {} : { issue: named ? "mapping-mismatch" : "缺少 planner、reviewer 插槽；请用 odai_routing_config 配置" }) };
+    }
+  }
+  return result;
+}
+
+export function parseLeadVerdict(text) {
+  const normalize = (line) => line.trim().replace(/^[*_`"'“”‘’「」『』]+|[*_`"'“”‘’「」『』。.]+$/gu, "").trim();
+  const lines = text.split(/\r?\n/u).filter(line => line.trim());
+  const verdicts = [...text.matchAll(/\bVERDICT\s*[:：]\s*[*_`"'“‘「『]*(pass|changes-requested)\b/giu)].map(match => match[1].toLowerCase());
+  if (new Set(verdicts).size > 1) return "invalid";
+  return /^VERDICT\s*[:：]\s*(pass|changes-requested)$/iu.exec(normalize(lines.at(-1) ?? ""))?.[1]?.toLowerCase() ?? "invalid";
+}