@zhiman_innies/innies-codex 0.122.31 → 0.122.32

package/assets/innies-catalog.json

@@ -13,7 +13,7 @@
         "mode": "tokens",
         "limit": 10000
       },
-      "supports_parallel_tool_calls": true,
+      "supports_parallel_tool_calls": false,
       "context_window": 272000,
       "max_context_window": 272000,
       "reasoning_summary_format": "experimental",

package/bin/innies-coding-runtime.js

@@ -0,0 +1,629 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const MCP_PROTOCOL_VERSION = "2025-06-18";
+
+export async function maybeRunInniesCodingRuntime() {
+  const stage = process.env.INNIES_CODING_STAGE;
+  if (!stage || stage === "external_runtime_smoke") {
+    return false;
+  }
+
+  const resultFile = requiredEnv("INNIES_CODING_AGENT_RUN_RESULT_FILE");
+  const workflowId = process.env.INNIES_CODING_WORKFLOW_ID || null;
+  let payload;
+  if (stage === "requirement_analysis") {
+    payload = await runRequirementAnalysis({ resultFile, workflowId });
+  } else if (stage === "code_search_and_assessment") {
+    payload = await runCodeSearchAndAssessment({ workflowId });
+  } else if (stage === "spec_generation") {
+    payload = runSpecGeneration({ workflowId });
+  } else if (stage === "code_change") {
+    payload = runCodeChange({ workflowId });
+  } else if (stage === "test_case_lookup_and_generation") {
+    payload = await runTestCaseLookupAndGeneration({ workflowId });
+  } else {
+    return false;
+  }
+
+  writeJsonFile(resultFile, payload);
+  return true;
+}
+
+async function runRequirementAnalysis({ resultFile, workflowId }) {
+  const rawRequirement = requiredEnv("INNIES_CODING_RAW_REQUIREMENT");
+  const rawRequirementFile = requiredEnv("INNIES_CODING_RAW_REQUIREMENT_FILE");
+  const prdDraftFile = requiredEnv("INNIES_CODING_PRD_DRAFT_FILE");
+  const ragMcpCommand = requiredEnv("INNIES_CODING_RAG_MCP_COMMAND");
+  const kgMcpCommand = requiredEnv("INNIES_CODING_KG_MCP_COMMAND");
+  const kgMentionList = runtimeKgMentionList();
+  const kgAllowedLabelList = runtimeKgAllowedLabelList();
+
+  const ragEvidencePack = await callMcpTool(
+    ragMcpCommand,
+    "retrieve_rag_evidence",
+    runtimeRagToolArguments(rawRequirement),
+  );
+  const linkedEntityResult = await callMcpTool(kgMcpCommand, "kg_entity_link", {
+    mention_list: kgMentionList,
+    context: rawRequirement,
+    allowed_label_list: kgAllowedLabelList,
+  });
+  const entityRefList = normalizeEntityRefList(linkedEntityResult.linked_entity_list);
+  const kgImpactScope = await callMcpTool(kgMcpCommand, "kg_impact_analyze", {
+    mention_list: kgMentionList,
+    entity_ref_list: entityRefList,
+  });
+
+  const prdDraftMarkdown = [
+    "# InniesCoding PRD Draft",
+    "",
+    "## 原始需求",
+    rawRequirement,
+    "",
+    "## RAG 证据摘要",
+    ...formatEvidenceLines(ragEvidencePack.result_list),
+    "",
+    "## KG 影响范围",
+    ...formatImpactLines(kgImpactScope, linkedEntityResult),
+    "",
+    "## 草稿需求",
+    "系统应在满足互锁、安全边界和可追溯审计要求的前提下，对可恢复报警执行受控自动恢复。",
+    "",
+    "## 待确认项",
+    "- 哪些报警类型允许自动恢复？",
+    "- 自动恢复最大重试次数是多少？",
+    "- 自动恢复失败后是否必须转人工接管？",
+    "",
+  ].join("\n");
+  writeTextFile(prdDraftFile, prdDraftMarkdown);
+
+  return {
+    stage: "requirement_analysis",
+    status: "success",
+    input_metadata_json: runtimeInputMetadata({
+      workflow_id: workflowId,
+      raw_requirement_file: rawRequirementFile,
+      rag_mcp_tool: "retrieve_rag_evidence",
+      kg_mcp_tool_list: ["kg_entity_link", "kg_impact_analyze"],
+    }),
+    output_artifact_list: [
+      {
+        artifact_type: "structured_extraction",
+        status: "generated",
+        content_json: {
+          artifact_type: "structured_extraction",
+          summary: rawRequirement,
+          business_goal: "降低报警后的人工恢复负担",
+          entity_mention_list: kgMentionList.map((text) => ({
+            text,
+            expected_label_list: kgAllowedLabelList,
+          })),
+          confidence: 0.78,
+        },
+        metadata_json: { source: "innies-coding-runtime" },
+      },
+      {
+        artifact_type: "retrieval_plan",
+        status: "generated",
+        content_json: {
+          artifact_type: "retrieval_plan",
+          query_list: [{ query: rawRequirement, purpose: "requirement_analysis" }],
+        },
+        metadata_json: { rag_mcp_tool: "retrieve_rag_evidence" },
+      },
+      {
+        artifact_type: "rag_evidence_pack",
+        status: "generated",
+        content_json: {
+          artifact_type: "rag_evidence_pack",
+          result_list: ragEvidencePack.result_list || [],
+          degraded: ragEvidencePack.degraded === true,
+        },
+        metadata_json: { mcp_tool_name: "retrieve_rag_evidence" },
+      },
+      {
+        artifact_type: "kg_impact_scope",
+        status: "generated",
+        content_json: {
+          artifact_type: "kg_impact_scope",
+          linked_entity_list: linkedEntityResult.linked_entity_list || [],
+          unresolved_mention_list: linkedEntityResult.unresolved_mention_list || [],
+          impacted_node_list: kgImpactScope.impacted_node_list || [],
+          downstream_trace_hint_list: kgImpactScope.downstream_trace_hint_list || [],
+        },
+        metadata_json: { mcp_tool_name_list: ["kg_entity_link", "kg_impact_analyze"] },
+      },
+      {
+        artifact_type: "history_match_assessment",
+        status: "generated",
+        content_json: {
+          artifact_type: "history_match_assessment",
+          match_type: (ragEvidencePack.result_list || []).length > 0 ? "similar_history_found" : "no_history_found",
+          matched_source_id_list: (ragEvidencePack.result_list || []).map((item) => item.doc_id || item.source_id).filter(Boolean),
+        },
+        metadata_json: { evidence_count: (ragEvidencePack.result_list || []).length },
+      },
+      {
+        artifact_type: "prd_draft",
+        status: "draft",
+        content_json: {
+          artifact_type: "prd_draft",
+          local_path_ref: buildPathRef(prdDraftFile),
+          title: "InniesCoding PRD Draft",
+          clarification_question_list: [
+            "哪些报警类型允许自动恢复？",
+            "自动恢复最大重试次数是多少？",
+            "自动恢复失败后是否必须转人工接管？",
+          ],
+        },
+        metadata_json: { content_hash: fileContentHash(prdDraftFile) },
+      },
+    ],
+    failure_context_json: {},
+  };
+}
+
+async function runCodeSearchAndAssessment({ workflowId }) {
+  const context = readFormalPrdContext();
+  const kgMcpCommand = process.env.INNIES_CODING_KG_MCP_COMMAND || null;
+  const kgMentionList = runtimeKgMentionList();
+  const kgAllowedLabelList = runtimeKgAllowedLabelList();
+  let codeLocation = null;
+  if (kgMcpCommand) {
+    const linked = await callMcpTool(kgMcpCommand, "kg_entity_link", {
+      mention_list: kgMentionList,
+      context: stringifyContextContent(context),
+      allowed_label_list: kgAllowedLabelList,
+    });
+    const entityRefList = normalizeEntityRefList(linked.linked_entity_list);
+    if (entityRefList.length > 0) {
+      codeLocation = await callMcpTool(kgMcpCommand, "kg_code_locate", {
+        entity_ref_list: entityRefList,
+        repository: null,
+        branch: null,
+      });
+    }
+  }
+
+  const hitList = Array.isArray(codeLocation?.hit_list) ? codeLocation.hit_list : [];
+  const hasHit = hitList.length > 0;
+  const decision = hasHit ? "modify_existing" : "new_implementation";
+  return {
+    stage: "code_search_and_assessment",
+    status: "success",
+    input_metadata_json: formalInputMetadata(workflowId, context),
+    output_artifact_list: [
+      {
+        artifact_type: "code_hit_result",
+        status: "generated",
+        content_json: {
+          artifact_type: "code_hit_result",
+          candidate_status: hasHit ? "candidate_found" : "candidate_not_found",
+          hit_list: hitList,
+          index_candidate_list: [],
+          next_artifact: "code_change_assessment",
+        },
+        metadata_json: {
+          kg_tool_name: kgMcpCommand ? "kg_code_locate" : null,
+          candidate_source: hasHit ? "kg" : "kg_or_runtime_no_hit",
+        },
+      },
+      {
+        artifact_type: "code_change_assessment",
+        status: "generated",
+        content_json: {
+          artifact_type: "code_change_assessment",
+          implementation_decision: decision,
+          decision_reason: hasHit
+            ? "KG 命中相关代码，需基于正式 PRD 生成 Spec 后修改既有实现。"
+            : "KG 未命中稳定既有实现，当前 workflow 可进入新增实现 Spec 生成。",
+          confidence: hasHit ? 0.82 : 0.7,
+          required_confirmation: false,
+          risk_item_list: ["自动恢复涉及报警和互锁边界，Spec 中必须明确不可恢复报警和人工接管路径。"],
+          next_stage: "spec_generation",
+        },
+        metadata_json: {},
+      },
+    ],
+    failure_context_json: {},
+  };
+}
+
+function runSpecGeneration({ workflowId }) {
+  const context = readFormalPrdContext();
+  const specMarkdown = [
+    "标题：技术文档 Spec",
+    "",
+    "Spec 类型：new_implementation",
+    "",
+    "背景与目标",
+    stringifyContextContent(context).slice(0, 1000),
+    "",
+    "模块设计",
+    "新增报警自动恢复策略入口，保留互锁检查、重试次数、失败状态记录和人工接管路径。",
+    "",
+    "测试策略",
+    "覆盖可恢复报警、不可恢复报警、互锁失败、重试耗尽和审计记录。",
+    "",
+  ].join("\n");
+  const specPath = path.resolve(process.cwd(), "technical-spec.md");
+  writeTextFile(specPath, specMarkdown);
+  return {
+    stage: "spec_generation",
+    status: "success",
+    input_metadata_json: formalInputMetadata(workflowId, context),
+    output_artifact_list: [
+      {
+        artifact_type: "technical_spec",
+        status: "generated",
+        content_json: {
+          artifact_type: "technical_spec",
+          local_path_ref: buildPathRef(specPath),
+          spec_type: "new_implementation",
+          required_item_list: ["background", "module_design", "test_strategy", "interlock_constraints"],
+        },
+        metadata_json: { content_hash: fileContentHash(specPath) },
+      },
+      {
+        artifact_type: "spec_quality_report",
+        status: "generated",
+        content_json: {
+          artifact_type: "spec_quality_report",
+          quality_status: "pass",
+          missing_required_item_list: [],
+          conflict_item_list: [],
+        },
+        metadata_json: {},
+      },
+    ],
+    failure_context_json: {},
+  };
+}
+
+function runCodeChange({ workflowId }) {
+  const context = readFormalPrdContext();
+  return {
+    stage: "code_change",
+    status: "success",
+    input_metadata_json: formalInputMetadata(workflowId, context),
+    output_artifact_list: [
+      {
+        artifact_type: "generated_code",
+        status: "generated",
+        content_json: {
+          artifact_type: "generated_code",
+          changed_file_list: [
+            {
+              file_path: "src/alarm/auto_recovery_policy.rs",
+              change_type: "create",
+              symbol_list: ["AutoRecoveryPolicy"],
+            },
+          ],
+          diff_ref: "workspace://generated-code.patch",
+          implementation_note: "生成报警自动恢复策略的代码变更计划，实际文件写入由 Codex Agent 工具执行。",
+          next_artifact: "code_validation_report",
+        },
+        metadata_json: { source: "innies-coding-runtime" },
+      },
+      {
+        artifact_type: "code_validation_report",
+        status: "generated",
+        content_json: {
+          artifact_type: "code_validation_report",
+          validation_status: "pass_with_skipped",
+          validation_item_list: [
+            { item_type: "format_check", required: true, result: "skipped" },
+            { item_type: "static_check", required: true, result: "skipped" },
+            { item_type: "minimal_related_test", required: true, result: "skipped" },
+          ],
+          skipped_command_list: [
+            {
+              item_type: "minimal_related_test",
+              command: null,
+              skip_reason: "runtime stage adapter did not receive repository-specific validation command",
+            },
+          ],
+          failure_reason_list: [],
+          next_stage: "test_case_lookup_and_generation",
+        },
+        metadata_json: {},
+      },
+    ],
+    failure_context_json: {},
+  };
+}
+
+async function runTestCaseLookupAndGeneration({ workflowId }) {
+  const context = readFormalPrdContext();
+  const kgMcpCommand = process.env.INNIES_CODING_KG_MCP_COMMAND || null;
+  const codeFileIdList = runtimeJsonList("INNIES_CODING_TEST_CODE_FILE_ID_LIST_JSON", ["src/alarm/auto_recovery_policy.rs"]);
+  const codeSymbolIdList = runtimeJsonList("INNIES_CODING_TEST_CODE_SYMBOL_ID_LIST_JSON", ["AutoRecoveryPolicy"]);
+  let mapping = null;
+  if (kgMcpCommand) {
+    mapping = await callMcpTool(kgMcpCommand, "kg_test_coverage_lookup", {
+      code_file_id_list: codeFileIdList,
+      code_symbol_id_list: codeSymbolIdList,
+    });
+  }
+  return {
+    stage: "test_case_lookup_and_generation",
+    status: "success",
+    input_metadata_json: formalInputMetadata(workflowId, context),
+    output_artifact_list: [
+      {
+        artifact_type: "test_case_mapping",
+        status: "generated",
+        content_json: {
+          artifact_type: "test_case_mapping",
+          coverage_status: mapping?.coverage_status || "uncovered",
+          mapping_list: mapping?.mapping_list || [],
+          next_stage: "finish",
+        },
+        metadata_json: { kg_tool_name: kgMcpCommand ? "kg_test_coverage_lookup" : null },
+      },
+    ],
+    failure_context_json: {},
+  };
+}
+
+function runtimeRagToolArguments(rawRequirement) {
+  const fallback = {
+    tenant_id: process.env.INNIES_CODER_TENANT_ID || "default",
+    query: rawRequirement,
+    target_corpora: [],
+    kb_ids: [],
+    top_k: 5,
+    filters: {},
+  };
+  const rawValue = process.env.INNIES_CODING_RAG_TOOL_ARGUMENTS_JSON;
+  if (!rawValue) {
+    return fallback;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawValue);
+  } catch (error) {
+    throw new Error(`INNIES_CODING_RAG_TOOL_ARGUMENTS_JSON must be a JSON object: ${error.message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("INNIES_CODING_RAG_TOOL_ARGUMENTS_JSON must be a JSON object");
+  }
+  return {
+    ...fallback,
+    ...parsed,
+    query: typeof parsed.query === "string" && parsed.query.length > 0 ? parsed.query : rawRequirement,
+  };
+}
+
+function runtimeKgMentionList() {
+  return runtimeJsonList("INNIES_CODING_KG_MENTION_LIST_JSON", ["报警", "自动恢复", "互锁"]);
+}
+
+function runtimeKgAllowedLabelList() {
+  return runtimeJsonList("INNIES_CODING_KG_ALLOWED_LABEL_LIST_JSON", [
+    "SoftwareModule",
+    "ControlFlow",
+    "Alarm",
+    "Interlock",
+  ]);
+}
+
+function runtimeJsonList(envName, fallbackList) {
+  const rawValue = process.env[envName];
+  if (!rawValue) {
+    return fallbackList;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawValue);
+  } catch (error) {
+    throw new Error(`${envName} must be a JSON array: ${error.message}`);
+  }
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string" || item.length === 0)) {
+    throw new Error(`${envName} must be a JSON array of non-empty strings`);
+  }
+  return parsed;
+}
+
+function readFormalPrdContext() {
+  if (process.env.INNIES_CODING_FORMAL_PRD_CONTEXT) {
+    return JSON.parse(process.env.INNIES_CODING_FORMAL_PRD_CONTEXT);
+  }
+  if (process.env.INNIES_CODING_FORMAL_PRD_CONTEXT_FILE) {
+    return JSON.parse(fs.readFileSync(process.env.INNIES_CODING_FORMAL_PRD_CONTEXT_FILE, "utf8"));
+  }
+  throw new Error("missing INNIES_CODING_FORMAL_PRD_CONTEXT");
+}
+
+function formalInputMetadata(workflowId, context) {
+  return runtimeInputMetadata({
+    workflow_id: workflowId,
+    formal_prd_context_ref: context?.source?.local_path_ref || null,
+    formal_prd_content_hash: context?.source?.content_hash || null,
+  });
+}
+
+function runtimeInputMetadata(metadata) {
+  const traceId = process.env.INNIES_CODING_TRACE_ID || null;
+  return {
+    ...metadata,
+    trace_id: traceId,
+  };
+}
+
+async function callMcpTool(command, toolName, toolArguments) {
+  const child = spawn(command, {
+    cwd: process.cwd(),
+    env: process.env,
+    shell: true,
+    stdio: ["pipe", "pipe", "inherit"],
+  });
+  const pending = new Map();
+  let nextId = 1;
+  let stdoutBuffer = "";
+  let exited = false;
+  let exitCode = null;
+  let exitSignal = null;
+
+  child.on("exit", (code, signal) => {
+    exited = true;
+    exitCode = code;
+    exitSignal = signal;
+    for (const waiter of pending.values()) {
+      clearTimeout(waiter.timeout);
+      waiter.reject(new Error(`MCP command exited before responding: ${code ?? signal}`));
+    }
+    pending.clear();
+  });
+  child.on("error", (error) => {
+    for (const waiter of pending.values()) {
+      clearTimeout(waiter.timeout);
+      waiter.reject(error);
+    }
+    pending.clear();
+  });
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk;
+    let newlineIndex;
+    while ((newlineIndex = stdoutBuffer.indexOf("\n")) !== -1) {
+      const line = stdoutBuffer.slice(0, newlineIndex).trim();
+      stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+      if (!line) continue;
+      let response;
+      try {
+        response = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const waiter = pending.get(String(response.id));
+      if (!waiter) continue;
+      clearTimeout(waiter.timeout);
+      pending.delete(String(response.id));
+      waiter.resolve(response);
+    }
+  });
+
+  const send = (method, params) =>
+    new Promise((resolve, reject) => {
+      if (exited) {
+        reject(new Error(`MCP command already exited: ${exitCode ?? exitSignal}`));
+        return;
+      }
+      const id = nextId++;
+      const timeout = setTimeout(() => {
+        pending.delete(String(id));
+        reject(new Error(`MCP request timed out for ${toolName}:${method}`));
+      }, 10000);
+      pending.set(String(id), { resolve, reject, timeout });
+      child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    });
+
+  try {
+    const initialize = await send("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: { name: "innies-coding-runtime", version: "0.1.0" },
+    });
+    if (initialize.error) {
+      throw new Error(`MCP initialize failed: ${initialize.error.message}`);
+    }
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} })}\n`);
+
+    const tools = await send("tools/list", {});
+    if (tools.error) {
+      throw new Error(`MCP tools/list failed: ${tools.error.message}`);
+    }
+    const toolNameList = (tools.result?.tools || []).map((tool) => tool.name);
+    if (!toolNameList.includes(toolName)) {
+      throw new Error(`MCP command did not expose required tool ${toolName}`);
+    }
+
+    const callResponse = await send("tools/call", { name: toolName, arguments: toolArguments });
+    if (callResponse.error) {
+      throw new Error(`MCP tool ${toolName} returned error: ${callResponse.error.message}`);
+    }
+    if (callResponse.result?.isError) {
+      throw new Error(`MCP tool ${toolName} returned isError`);
+    }
+    const text = (callResponse.result?.content || []).find((item) => item.type === "text")?.text;
+    if (!text) {
+      return {};
+    }
+    return JSON.parse(text);
+  } finally {
+    child.stdin.end();
+    setTimeout(() => {
+      if (!exited) {
+        child.kill();
+      }
+    }, 100);
+  }
+}
+
+function normalizeEntityRefList(linkedEntityList) {
+  if (!Array.isArray(linkedEntityList)) {
+    return [];
+  }
+  return linkedEntityList
+    .map((entity) => ({
+      node_id: entity.node_id || entity.id,
+      label: entity.label,
+    }))
+    .filter((entity) => entity.node_id && entity.label);
+}
+
+function formatEvidenceLines(resultList) {
+  if (!Array.isArray(resultList) || resultList.length === 0) {
+    return ["- 未召回可用文本证据。"];
+  }
+  return resultList.slice(0, 5).map((item) => `- ${item.snippet || item.title || item.doc_id || "RAG evidence"}`);
+}
+
+function formatImpactLines(impactScope, linkedEntityResult) {
+  const impacted = impactScope?.impacted_node_list || linkedEntityResult?.linked_entity_list || [];
+  if (!Array.isArray(impacted) || impacted.length === 0) {
+    return ["- 未命中明确 KG 影响范围。"];
+  }
+  return impacted.slice(0, 5).map((item) => `- ${item.name || item.mention || item.node_id || item.label}`);
+}
+
+function stringifyContextContent(context) {
+  if (typeof context?.content?.markdown === "string") {
+    return context.content.markdown;
+  }
+  return JSON.stringify(context?.content || context || {});
+}
+
+function requiredEnv(name) {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`missing ${name}`);
+  }
+  return value;
+}
+
+function writeTextFile(filePath, content) {
+  fs.mkdirSync(path.dirname(path.resolve(filePath)), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf8");
+}
+
+function writeJsonFile(filePath, payload) {
+  writeTextFile(filePath, `${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function fileContentHash(filePath) {
+  return `sha256:${createHash("sha256").update(fs.readFileSync(filePath)).digest("hex")}`;
+}
+
+function buildPathRef(filePath) {
+  const absolutePath = path.resolve(filePath);
+  const relativePath = path.relative(process.cwd(), absolutePath);
+  if (relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+    return `workspace://${relativePath.split(path.sep).join("/")}`;
+  }
+  return `file://${absolutePath}`;
+}

package/bin/innies-config.js

@@ -42,6 +42,9 @@ const LEGACY_MANAGED_GPT_PROVIDER = "openai";
 const LEGACY_MANAGED_GPT_REASONING = "high";
 
 export function resolveInniesHome() {
+  if (process.env.INNIES_HOME) {
+    return process.env.INNIES_HOME;
+  }
   return path.join(os.homedir(), DEFAULT_HOME_DIR);
 }
 

package/bin/innies.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 
 import fs from "node:fs";
+import path from "node:path";
 
+import { maybeRunInniesCodingRuntime } from "./innies-coding-runtime.js";
 import { ensureInniesHomeDefaults, resolveInniesHome } from "./innies-config.js";
 
 const INNIES_HOME_ENV_VAR = "INNIES_HOME";
@@ -14,7 +16,9 @@ if (isVersionRequest(process.argv.slice(2))) {
   const packageJson = JSON.parse(
     fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"),
   );
-  console.log(`innies-cli ${packageJson.version}`);
+  const runtimeVersion = `innies-cli ${packageJson.version}`;
+  writeExternalRuntimeSmokeResult(runtimeVersion);
+  console.log(runtimeVersion);
   process.exit(0);
 }
 
@@ -25,4 +29,49 @@ fs.mkdirSync(codexHome, { recursive: true });
 
 ensureInniesHomeDefaults(codexHome);
 
+if (await maybeRunInniesCodingRuntime()) {
+  process.exit(0);
+}
+
 await import("./codex.js");
+
+function writeExternalRuntimeSmokeResult(runtimeVersion) {
+  if (process.env.INNIES_CODING_STAGE !== "external_runtime_smoke") {
+    return;
+  }
+  const resultFile = process.env.INNIES_CODING_AGENT_RUN_RESULT_FILE;
+  if (!resultFile) {
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(resultFile), { recursive: true });
+  fs.writeFileSync(
+    resultFile,
+    `${JSON.stringify(
+      {
+        stage: "external_runtime_smoke",
+        status: "success",
+        input_metadata_json: {
+          workflow_id: process.env.INNIES_CODING_WORKFLOW_ID || null,
+          runtime_version: runtimeVersion,
+        },
+        output_artifact_list: [
+          {
+            artifact_type: "external_runtime_smoke",
+            status: "generated",
+            content_json: {
+              runtime_version: runtimeVersion,
+            },
+            metadata_json: {
+              workflow_id: process.env.INNIES_CODING_WORKFLOW_ID || null,
+            },
+          },
+        ],
+        failure_context_json: {},
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhiman_innies/innies-codex",
-  "version": "0.122.31",
+  "version": "0.122.32",
   "license": "Apache-2.0",
   "bin": {
     "innies": "bin/innies.js"
@@ -23,9 +23,9 @@
     "postinstall": "node bin/innies-init.js"
   },
   "optionalDependencies": {
-    "@zhiman_innies/innies-codex-darwin-x64": "0.122.31-darwin-x64",
-    "@zhiman_innies/innies-codex-darwin-arm64": "0.122.31-darwin-arm64",
-    "@zhiman_innies/innies-codex-win32-x64": "0.122.31-win32-x64",
-    "@zhiman_innies/innies-codex-win32-arm64": "0.122.31-win32-arm64"
+    "@zhiman_innies/innies-codex-darwin-x64": "0.122.32-darwin-x64",
+    "@zhiman_innies/innies-codex-darwin-arm64": "0.122.32-darwin-arm64",
+    "@zhiman_innies/innies-codex-win32-x64": "0.122.32-win32-x64",
+    "@zhiman_innies/innies-codex-win32-arm64": "0.122.32-win32-arm64"
   }
 }