@lazyingart/agintiflow 0.20.195 → 0.20.196

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.195",
+  "version": "0.20.196",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",
@@ -135,6 +135,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "express": "^5.1.0",
+    "fast-xml-parser": "^5.8.0",
     "openai": "^6.3.0",
     "playwright": "^1.55.0"
   }

package/scripts/smoke-auxiliary-tools.js

@@ -73,6 +73,31 @@ try {
   await fs.access(path.join(workspace, "artifacts/images/dry-run/task_manifest.json"));
   const payloadText = await fs.readFile(path.join(workspace, "artifacts/images/dry-run/request_payload.redacted.json"), "utf8");
   assert(payloadText.includes("nano-banana-2"), "redacted image payload was not written");
+  const referencePng = Buffer.from(
+    "iVBORw0KGgoAAAANSUhEUgAAAAIAAAADCAYAAACJ7f8GAAAADElEQVR42mP8z8AARAAAIf4BfQKxMQAAAABJRU5ErkJggg==",
+    "base64"
+  );
+  await fs.mkdir(path.join(workspace, "refs"), { recursive: true });
+  await fs.writeFile(path.join(workspace, "refs/reference.png"), referencePng);
+  const referenceDryRun = await generateImage(
+    {
+      prompt: "Use the reference image geometry for a diagnostic dry run.",
+      outputDir: "artifacts/images/reference-dry-run",
+      outputStem: "reference",
+      referenceImages: ["refs/reference.png"],
+      matchReferenceSize: true,
+      dryRun: true,
+    },
+    {
+      commandCwd: workspace,
+      allowFileTools: true,
+    }
+  );
+  assert(referenceDryRun.ok && /Reference-size matching/i.test(referenceDryRun.geometryNotice || ""), "reference dry run did not report geometry notice");
+  const referenceManifest = JSON.parse(await fs.readFile(path.join(workspace, "artifacts/images/reference-dry-run/task_manifest.json"), "utf8"));
+  assert(referenceManifest.referenceImages?.[0]?.dimensions?.width === 2, "reference manifest did not record source image width");
+  assert(referenceManifest.referenceImages?.[0]?.dimensions?.height === 3, "reference manifest did not record source image height");
+  assert(referenceManifest.matchReferenceSize === true, "reference manifest did not record matchReferenceSize");
   const veniceDryRun = await generateImage(
     {
       provider: "venice",
@@ -139,6 +164,12 @@ try {
   assert(cliImageResult.actualFormat === "png", "direct image CLI did not select PNG fallback");
   assert(/raster PNG/i.test(cliImageResult.formatNotice || ""), "direct image CLI did not explain SVG-to-PNG fallback");
   await fs.access(path.join(workspace, "artifacts/images/cli-svg-fallback/task_manifest.json"));
+  const cliImageHelp = await execFile(process.execPath, [path.join(repoRoot, "bin/aginti-cli.js"), "--no-auto-update", "image", "--help"], {
+    cwd: repoRoot,
+    env: { ...process.env, AGINTIFLOW_HOME: process.env.AGINTIFLOW_HOME },
+  });
+  assert(cliImageHelp.stdout.includes("--reference"), "aginti image --help did not show reference-image options");
+  assert(cliImageHelp.stdout.includes("--match-reference-size"), "aginti image --help did not show match-reference-size");
 
   const blocked = await generateImage(
     {
@@ -187,10 +218,12 @@ try {
           "image_skill_listed",
           "venice_image_skill_listed",
           "generate_image_dry_run",
+          "reference_image_manifest_dimensions",
           "auto_venice_when_grsai_missing",
           "venice_generate_image_dry_run",
           "svg_request_png_fallback",
           "direct_image_cli_svg_request_png_fallback",
+          "direct_image_cli_subcommand_help",
           "generate_image_guardrail",
           "mock_agent_image_tool",
         ],

package/scripts/smoke-cli-chat.js

@@ -786,6 +786,10 @@ try {
   if (!zhHelpResult.stdout.includes("命令:") || !zhHelpResult.stdout.includes("输入普通任务")) {
     throw new Error("interactive --language zh-Hans did not localize CLI help");
   }
+  const zhLeadingLanguageStatus = await runCli(["--language", "zh-Hans", "chat"], "/status\n/exit\n");
+  if (!zhLeadingLanguageStatus.stdout.includes("language=zh-Hans")) {
+    throw new Error("leading --language zh-Hans was stripped before interactive status");
+  }
   const skillsResult = await runChat("/skills website\n/exit\n");
   if (!skillsResult.stdout.includes("website-app") || !skillsResult.stdout.includes("Website And App Builder")) {
     throw new Error("interactive /skills did not show matching built-in skills");
@@ -956,6 +960,7 @@ try {
           "prompt-redraw-fast-path",
           "committed-user-no-cwd-footer",
           "cli-i18n",
+          "leading-language-option",
           "user-prompt-label",
           "escape-policy",
           "composer-history-recall",

package/scripts/smoke-coding-tools.js

@@ -179,6 +179,19 @@ try {
   assert(cdataSvgResult.ok === false, "CDATA-wrapped SVG write should be marked not ok");
   assert(cdataSvgResult.artifactValidation?.kind === "svg", "SVG validation result missing");
   assert(/CDATA/i.test(cdataSvgResult.artifactValidation.errors.join(" ")), "CDATA SVG validation did not explain the wrapper problem");
+  const invalidXmlSvgResult = await executeWorkspaceTool(
+    "write_file",
+    {
+      path: "figures/invalid-unescaped-text.svg",
+      content: '<svg xmlns="http://www.w3.org/2000/svg" width="160" height="40"><text x="4" y="24">latency < 50 ms</text></svg>',
+    },
+    workspaceToolConfig
+  );
+  assert(invalidXmlSvgResult.ok === false, "SVG write with unescaped text '<' should be marked not ok");
+  assert(
+    /XML parser rejected/i.test(invalidXmlSvgResult.artifactValidation?.errors?.join(" ") || ""),
+    "invalid SVG XML was not rejected by the XML parser"
+  );
   const validSvgResult = await executeWorkspaceTool(
     "write_file",
     {
@@ -1265,6 +1278,7 @@ try {
           "resume_runtime_time_context",
           "virtual_workspace_path",
           "svg_cdata_validation_failure",
+          "svg_unescaped_text_xml_validation_failure",
           "svg_standalone_validation_pass",
           "apply_patch",
           "multi_file_patch",

package/scripts/smoke-model-roles.js

@@ -24,6 +24,7 @@ import {
 import { buildScsEvidenceLedger, deriveScsTaskContract, evaluateScsEvidence } from "../src/scs-evidence.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { classifyGoalIntent, isDirectAnswerIntent } from "../src/goal-intent.js";
+import { languageWriterDefaults } from "../src/writing-specialist.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -111,6 +112,10 @@ const envSnapshot = {
   OPENAI_BASE_URL: process.env.OPENAI_BASE_URL,
   LLM_BASE_URL: process.env.LLM_BASE_URL,
   AGINTI_MAIN_REASONING: process.env.AGINTI_MAIN_REASONING,
+  OPENAI_API_KEY: process.env.OPENAI_API_KEY,
+  DEEPSEEK_API_KEY: process.env.DEEPSEEK_API_KEY,
+  AGINTI_WRITING_PROVIDER_ZH: process.env.AGINTI_WRITING_PROVIDER_ZH,
+  AGINTI_WRITING_MODEL_ZH: process.env.AGINTI_WRITING_MODEL_ZH,
 };
 process.env.OPENAI_BASE_URL = "https://openai-compatible.example/v1";
 process.env.LLM_BASE_URL = "https://generic-compatible.example/v1";
@@ -123,6 +128,18 @@ process.env.AGINTI_MAIN_REASONING = "none";
 assert(getModelRoleDefaults().main.reasoning === "", "none main reasoning should normalize to omitted reasoning");
 assert(normalizeReasoningEffort("min") === "minimal", "min reasoning alias should normalize to minimal");
 assert(normalizeReasoningEffort("extra-high") === "xhigh", "extra-high reasoning alias should normalize to xhigh");
+process.env.DEEPSEEK_API_KEY = "test-deepseek-key";
+process.env.OPENAI_API_KEY = "test-openai-key";
+delete process.env.AGINTI_WRITING_PROVIDER_ZH;
+delete process.env.AGINTI_WRITING_MODEL_ZH;
+const zhWriterRoute = languageWriterDefaults({ language: "zh-Hans", writingBrief: "写一段小说。" }, { provider: "mock", model: "mock-agent" });
+assert(zhWriterRoute.provider === "deepseek" && zhWriterRoute.model === "deepseek-v4-pro", "Chinese writing should default to DeepSeek Pro when available");
+const enWriterRoute = languageWriterDefaults({ language: "en", writingBrief: "Write a scene." }, { provider: "mock", model: "mock-agent" });
+assert(enWriterRoute.provider === "openai" && enWriterRoute.model, "English writing should default to OpenAI when available");
+process.env.AGINTI_WRITING_PROVIDER_ZH = "qwen";
+process.env.AGINTI_WRITING_MODEL_ZH = "qwen-test-writer";
+const zhEnvWriterRoute = languageWriterDefaults({ language: "zh-Hans", writingBrief: "写一段小说。" }, { provider: "mock", model: "mock-agent" });
+assert(zhEnvWriterRoute.provider === "qwen" && zhEnvWriterRoute.model === "qwen-test-writer", "language-specific writer env should override auto routing");
 for (const [key, value] of Object.entries(envSnapshot)) {
   if (value === undefined) delete process.env[key];
   else process.env[key] = value;
@@ -578,6 +595,10 @@ const jsonObjectContract = deriveScsTaskContract({
 const virtualFileContract = deriveScsTaskContract({
   goal: "Create file: /workspace/virtual-output.txt with virtual Docker path support.",
 });
+const requiredWriterToolContract = deriveScsTaskContract({
+  goal: "Call writing_specialist again and create final/story.md.",
+  taskProfile: "writing",
+});
 const outputListContract = deriveScsTaskContract({
   goal: [
     "Create:",
@@ -647,6 +668,10 @@ assert(
     !virtualFileContract.requiredEvidence.some((item) => item.category === "artifact"),
   "virtual output filename should require file evidence without treating output in the filename as an artifact"
 );
+assert(
+  requiredWriterToolContract.requiredToolCalls.includes("writing_specialist"),
+  "SCS should infer explicitly required specialist tool calls"
+);
 assert(
   outputListContract.exactOutputPaths.includes("work/demo/generate_items.py") &&
     outputListContract.exactOutputPaths.includes("work/demo/review_items.py") &&
@@ -691,6 +716,28 @@ const checkedCodeEval = evaluateScsEvidence(
   })
 );
 assert(checkedCodeEval.ok, "code task should finish when file and command evidence are both present");
+const missingWriterToolEval = evaluateScsEvidence(
+  requiredWriterToolContract,
+  buildScsEvidenceLedger({
+    context: { events: [{ type: "file.changed", data: { path: "final/story.md" } }] },
+  })
+);
+assert(
+  !missingWriterToolEval.ok && missingWriterToolEval.missingToolCalls.includes("writing_specialist"),
+  "SCS should reject finish when required specialist call is missing"
+);
+const presentWriterToolEval = evaluateScsEvidence(
+  requiredWriterToolContract,
+  buildScsEvidenceLedger({
+    context: {
+      events: [
+        { type: "file.changed", data: { path: "final/story.md" } },
+        { type: "tool.completed", data: { toolName: "writing_specialist", ok: true, artifactPath: "artifacts/writer.json" } },
+      ],
+    },
+  })
+);
+assert(presentWriterToolEval.ok, "SCS should accept required specialist call when tool evidence is present");
 
 const blockedFileFinish = await reviewScsFinish(
   { mock: true },
@@ -740,6 +787,7 @@ console.log(
         "role-defaults",
         "openai-base-url",
         "provider-default-reasoning",
+        "writing-specialist-language-routing",
         "openai-chat-reasoning-payload",
         "goal-intent-direct-answer",
         "route-overrides",
@@ -754,6 +802,7 @@ console.log(
         "scs-student-validator-replan",
         "scs-evidence-stdout",
         "scs-contract-evidence-ledger",
+        "scs-required-tool-call-contract",
         "cli-models-command",
         "venice-shortcut",
       ],

package/src/auxiliary-tools.js

@@ -130,6 +130,66 @@ function mimeFromPath(filePath) {
   return "image/png";
 }
 
+function imageDimensionsFromBuffer(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 12) return null;
+
+  if (buffer.length >= 24 && buffer.readUInt32BE(0) === 0x89504e47 && buffer.toString("ascii", 12, 16) === "IHDR") {
+    return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20), format: "png" };
+  }
+
+  if (buffer.toString("ascii", 0, 3) === "GIF" && buffer.length >= 10) {
+    return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8), format: "gif" };
+  }
+
+  if (buffer[0] === 0xff && buffer[1] === 0xd8) {
+    let offset = 2;
+    while (offset + 9 < buffer.length) {
+      while (buffer[offset] === 0xff) offset += 1;
+      const marker = buffer[offset];
+      offset += 1;
+      if ([0xd8, 0xd9, 0x01].includes(marker) || (marker >= 0xd0 && marker <= 0xd7)) continue;
+      if (offset + 2 > buffer.length) break;
+      const length = buffer.readUInt16BE(offset);
+      if (length < 2 || offset + length > buffer.length) break;
+      if (
+        [0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker) &&
+        offset + 7 < buffer.length
+      ) {
+        return { width: buffer.readUInt16BE(offset + 5), height: buffer.readUInt16BE(offset + 3), format: "jpeg" };
+      }
+      offset += length;
+    }
+  }
+
+  if (buffer.toString("ascii", 0, 4) === "RIFF" && buffer.toString("ascii", 8, 12) === "WEBP") {
+    let offset = 12;
+    while (offset + 8 <= buffer.length) {
+      const chunk = buffer.toString("ascii", offset, offset + 4);
+      const size = buffer.readUInt32LE(offset + 4);
+      const data = offset + 8;
+      if (chunk === "VP8X" && data + 10 <= buffer.length) {
+        const width = 1 + buffer.readUIntLE(data + 4, 3);
+        const height = 1 + buffer.readUIntLE(data + 7, 3);
+        return { width, height, format: "webp" };
+      }
+      if (chunk === "VP8 " && data + 10 <= buffer.length && buffer[data + 3] === 0x9d && buffer[data + 4] === 0x01 && buffer[data + 5] === 0x2a) {
+        return {
+          width: buffer.readUInt16LE(data + 6) & 0x3fff,
+          height: buffer.readUInt16LE(data + 8) & 0x3fff,
+          format: "webp",
+        };
+      }
+      offset += 8 + size + (size % 2);
+    }
+  }
+
+  return null;
+}
+
+function dimensionsEqual(a, b) {
+  return Boolean(a && b && Number(a.width) === Number(b.width) && Number(a.height) === Number(b.height));
+}
+
 function parseJsonResponse(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -163,6 +223,33 @@ function redactPayload(payload) {
   return copy;
 }
 
+function extractFailureReason(payload = {}) {
+  const seen = new Set();
+  const reasons = [];
+  const interesting = /^(?:failure_reason|failureReason|fail_reason|failReason|reason|error|error_message|errorMessage|message|msg|detail|details|code|status)$/i;
+  const walk = (value, depth = 0, key = "") => {
+    if (value === null || value === undefined || depth > 4 || reasons.length >= 12) return;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      if (!interesting.test(key)) return;
+      const text = redactSensitiveText(String(value)).replace(/\s+/g, " ").trim();
+      if (text && !seen.has(`${key}:${text}`)) {
+        seen.add(`${key}:${text}`);
+        reasons.push(`${key}: ${text}`);
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.slice(0, 8).forEach((item) => walk(item, depth + 1, key));
+      return;
+    }
+    if (typeof value === "object") {
+      for (const [childKey, childValue] of Object.entries(value)) walk(childValue, depth + 1, childKey);
+    }
+  };
+  walk(payload);
+  return reasons.join("; ").slice(0, 1200) || "";
+}
+
 function grsaiKey() {
   return String(process.env.GRSAI || process.env.GRSAI_API_KEY || "").trim();
 }
@@ -181,8 +268,18 @@ export function listAuxiliarySkills() {
 async function referenceToUrl(item, config) {
   const value = String(item || "").trim();
   if (!value) return { url: "", redacted: "" };
-  if (/^https?:\/\//i.test(value)) return { url: value, redacted: value };
-  if (value.startsWith("data:")) return { url: value, redacted: `<data-uri length=${value.length}>` };
+  if (/^https?:\/\//i.test(value)) return { url: value, redacted: value, source: "url", dimensions: null };
+  if (value.startsWith("data:")) {
+    const match = value.match(/^data:([^;,]+);base64,([\s\S]+)$/i);
+    const buffer = match ? Buffer.from(match[2], "base64") : null;
+    return {
+      url: value,
+      redacted: `<data-uri length=${value.length}>`,
+      source: "data-uri",
+      bytes: buffer?.length || 0,
+      dimensions: buffer ? imageDimensionsFromBuffer(buffer) : null,
+    };
+  }
 
   const target = resolveWorkspacePath(config, value);
   const stat = await fs.stat(target.absolutePath);
@@ -192,6 +289,10 @@ async function referenceToUrl(item, config) {
   return {
     url: `data:${mimeFromPath(target.relativePath)};base64,${buffer.toString("base64")}`,
     redacted: `<${target.relativePath} data-uri bytes=${buffer.length}>`,
+    source: "workspace-file",
+    path: target.relativePath,
+    bytes: buffer.length,
+    dimensions: imageDimensionsFromBuffer(buffer),
   };
 }
 
@@ -302,6 +403,7 @@ async function downloadImage(url, destination, signal = null) {
   return {
     bytes: buffer.length,
     sha256: hashBuffer(buffer),
+    dimensions: imageDimensionsFromBuffer(buffer),
   };
 }
 
@@ -313,6 +415,7 @@ async function writeBase64Image(image, destination) {
   return {
     bytes: buffer.length,
     sha256: hashBuffer(buffer),
+    dimensions: imageDimensionsFromBuffer(buffer),
   };
 }
 
@@ -401,6 +504,12 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
     imagePaths.push(relativePath);
     downloads.push({ path: relativePath, ...info });
   }
+  const referenceDimensions = manifest.referenceDimensions || null;
+  const matchReferenceSize = Boolean(manifest.matchReferenceSize);
+  const geometryMismatch =
+    matchReferenceSize && referenceDimensions
+      ? downloads.find((item) => item.dimensions && !dimensionsEqual(item.dimensions, referenceDimensions))
+      : null;
 
   manifest.provider = "venice";
   manifest.host = base;
@@ -411,6 +520,9 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
   manifest.status = "succeeded";
   manifest.finishedAt = new Date().toISOString();
   manifest.downloadedFiles = downloads;
+  if (geometryMismatch) {
+    manifest.geometryNotice = `Reference size requested (${referenceDimensions.width}x${referenceDimensions.height}), but generated output ${geometryMismatch.path} is ${geometryMismatch.dimensions.width}x${geometryMismatch.dimensions.height}.`;
+  }
   if (resultPayload.id) manifest.taskId = String(resultPayload.id);
   await writeJson(manifestPath, manifest);
 
@@ -427,6 +539,7 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
     requestedFormat: formatInfo.requestedFormat,
     actualFormat: format,
     formatNotice: formatInfo.notice,
+    geometryNotice: manifest.geometryNotice || "",
     summary: `${imagePaths.length} image(s) generated through Venice${formatInfo.notice ? ` (${formatInfo.notice})` : ""}`,
   };
 }
@@ -456,6 +569,15 @@ export async function generateImage(args = {}, config = {}) {
     const converted = await referenceToUrl(item, config);
     if (converted.url) references.push(converted);
   }
+  const referenceMetadata = references.map((item) => ({
+    source: item.source || "",
+    path: item.path || "",
+    redacted: item.redacted || "",
+    bytes: item.bytes || 0,
+    dimensions: item.dimensions || null,
+  }));
+  const referenceDimensions = references.find((item) => item.dimensions)?.dimensions || null;
+  const matchReferenceSize = Boolean(args.matchReferenceSize || args.match_ref_size || args.matchRefSize);
 
   const provider = args.provider ? normalizeImageProvider(args.provider) : defaultImageProvider(config);
   const formatInfo = normalizeOutputFormat(args);
@@ -479,6 +601,7 @@ export async function generateImage(args = {}, config = {}) {
 
   const redactedPayload = redactPayload(payload);
   redactedPayload.urls = references.map((item) => item.redacted);
+  if (matchReferenceSize) redactedPayload.matchReferenceSize = true;
   const promptPath = path.join(target.absolutePath, "prompt.txt");
   const requestPath = path.join(target.absolutePath, "request_payload.redacted.json");
   const manifestPath = path.join(target.absolutePath, "task_manifest.json");
@@ -496,9 +619,18 @@ export async function generateImage(args = {}, config = {}) {
     outputDir: target.relativePath,
     promptFile: path.posix.join(target.relativePath, "prompt.txt"),
     requestPayloadRedacted: path.posix.join(target.relativePath, "request_payload.redacted.json"),
+    referenceImages: referenceMetadata,
+    referenceDimensions,
+    matchReferenceSize,
     status: args.dryRun ? "prepared" : "started",
     createdAt: new Date().toISOString(),
   };
+  if (matchReferenceSize && !referenceDimensions) {
+    manifest.geometryNotice = "Reference-size matching was requested, but no local reference image dimensions could be detected.";
+  } else if (matchReferenceSize) {
+    manifest.geometryNotice =
+      "Reference-size matching was requested. AgInTiFlow records and checks output dimensions, but the current image backends may not preserve exact source geometry.";
+  }
   await writeJson(manifestPath, manifest);
 
   if (args.dryRun) {
@@ -515,6 +647,7 @@ export async function generateImage(args = {}, config = {}) {
       requestedFormat: formatInfo.requestedFormat,
       actualFormat: formatInfo.actualFormat,
       formatNotice: formatInfo.notice,
+      geometryNotice: manifest.geometryNotice || "",
       summary: `Prepared redacted image-generation payload without calling the provider.${formatInfo.notice ? ` ${formatInfo.notice}` : ""}`,
     };
   }
@@ -568,10 +701,13 @@ export async function generateImage(args = {}, config = {}) {
 
   const status = resultPayload.status || resultPayload?.data?.status;
   if (status !== "succeeded") {
+    const failureReason = extractFailureReason(resultPayload) || `status: ${status || "unknown"}`;
     manifest.status = status || "failed";
+    manifest.failureReason = failureReason;
+    manifest.resultResponse = path.posix.join(target.relativePath, "result_response.json");
     manifest.finishedAt = new Date().toISOString();
     await writeJson(manifestPath, manifest);
-    throw new Error(`Image generation failed with status ${status || "unknown"}. See ${manifestPath}.`);
+    throw new Error(`Image generation failed with status ${status || "unknown"}: ${failureReason}. See ${manifestPath}.`);
   }
 
   const urls = resultUrls(resultPayload);
@@ -588,6 +724,10 @@ export async function generateImage(args = {}, config = {}) {
     imagePaths.push(relativePath);
     downloads.push({ path: relativePath, ...info });
   }
+  const geometryMismatch =
+    matchReferenceSize && referenceDimensions
+      ? downloads.find((item) => item.dimensions && !dimensionsEqual(item.dimensions, referenceDimensions))
+      : null;
 
   manifest.status = "succeeded";
   manifest.requestedFormat = formatInfo.requestedFormat;
@@ -595,6 +735,9 @@ export async function generateImage(args = {}, config = {}) {
   if (formatInfo.notice) manifest.formatNotice = formatInfo.notice;
   manifest.finishedAt = new Date().toISOString();
   manifest.downloadedFiles = downloads;
+  if (geometryMismatch) {
+    manifest.geometryNotice = `Reference size requested (${referenceDimensions.width}x${referenceDimensions.height}), but generated output ${geometryMismatch.path} is ${geometryMismatch.dimensions.width}x${geometryMismatch.dimensions.height}.`;
+  }
   await writeJson(manifestPath, manifest);
 
   return {
@@ -609,6 +752,7 @@ export async function generateImage(args = {}, config = {}) {
     requestedFormat: formatInfo.requestedFormat,
     actualFormat: manifest.actualFormat,
     formatNotice: formatInfo.notice,
+    geometryNotice: manifest.geometryNotice || "",
     summary: `${imagePaths.length} image(s) generated${formatInfo.notice ? ` (${formatInfo.notice})` : ""}`,
   };
 }

package/src/cli.js

@@ -825,6 +825,7 @@ function parseImageCommandArgs(argv = []) {
     imageSize: "",
     host: "",
     referenceImages: [],
+    matchReferenceSize: false,
     commandCwd: "",
     requestTimeoutMs: "",
     pollTimeoutMs: "",
@@ -861,6 +862,11 @@ function parseImageCommandArgs(argv = []) {
       index += 1;
       continue;
     }
+    if (arg === "--match-reference-size" || arg === "--match-ref-size") {
+      result.matchReferenceSize = true;
+      index += 1;
+      continue;
+    }
     if (arg === "--stdin") {
       result.stdin = true;
       index += 1;
@@ -919,9 +925,10 @@ function parseImageCommandArgs(argv = []) {
 
 function printImageCommandUsage() {
   console.log(
-    'Usage: aginti image [generate] [--json] [--dry-run] [--provider grsai|venice] [--model MODEL] [--format png|webp|svg] [--output-dir DIR] [--output-stem STEM] [--aspect-ratio 1:1] [--image-size 1K|2K|4K|1024x1024] [--reference path-or-url] "prompt"'
+    'Usage: aginti image [generate] [--json] [--dry-run] [--provider grsai|venice] [--model MODEL] [--format png|webp|svg] [--output-dir DIR] [--output-stem STEM] [--aspect-ratio 1:1] [--image-size 1K|2K|4K|1024x1024] [--reference path-or-url] [--match-reference-size] "prompt"'
   );
   console.log("Direct image CLI calls the same generate_image tool as the web API. SVG/vector requests return PNG with requestedFormat/actualFormat/formatNotice.");
+  console.log("--reference accepts local paths, URLs, or data URIs. Diagnostics record reference/output dimensions when available.");
   console.log('Agent-mediated image work is still available as: aginti --image "draw a poster"');
 }
 
@@ -946,11 +953,13 @@ function printImageCommandResult(result = {}) {
     console.log(`format: ${requested}${requested === actual ? "" : ` -> ${actual}`}`);
   }
   if (result.formatNotice) console.log(`notice: ${result.formatNotice}`);
+  if (result.geometryNotice) console.log(`geometry: ${result.geometryNotice}`);
   if (result.path) console.log(`path: ${result.path}`);
   if (result.imagePaths?.length) console.log(`images: ${result.imagePaths.join(", ")}`);
   if (result.manifestPath) console.log(`manifest: ${result.manifestPath}`);
   if (result.promptPath) console.log(`prompt: ${result.promptPath}`);
   if (result.requestPayloadPath) console.log(`request: ${result.requestPayloadPath}`);
+  if (result.failureReason) console.log(`failure: ${result.failureReason}`);
   if (result.reason) console.log(`reason: ${result.reason}`);
 }
 
@@ -994,6 +1003,7 @@ async function handleImageCommand(argv, { commandCwd = process.cwd() } = {}) {
       imageSize: parsed.imageSize || undefined,
       host: parsed.host || undefined,
       referenceImages: parsed.referenceImages,
+      matchReferenceSize: parsed.matchReferenceSize,
       requestTimeoutMs: parsed.requestTimeoutMs || undefined,
       pollTimeoutMs: parsed.pollTimeoutMs || undefined,
       pollIntervalMs: parsed.pollIntervalMs || undefined,
@@ -1107,6 +1117,7 @@ function stripLeadingGlobalOptions(argv = []) {
   let index = 0;
   const options = {
     commandCwd: "",
+    language: "",
   };
   while (index < argv.length) {
     const arg = argv[index];
@@ -1115,7 +1126,15 @@ function stripLeadingGlobalOptions(argv = []) {
       continue;
     }
     if (arg === "--language" || arg === "--lang" || arg === "-L") {
-      index += readOption(argv, index) ? 2 : 1;
+      const first = readOption(argv, index);
+      const second = argv[index + 2] && !String(argv[index + 2]).startsWith("--") ? argv[index + 2] : "";
+      if (["cn", "zh"].includes(String(first || "").toLowerCase()) && ["s", "t"].includes(String(second || "").toLowerCase())) {
+        options.language = resolveLanguage(`${first}-${second}`);
+        index += 3;
+        continue;
+      }
+      options.language = resolveLanguage(first);
+      index += first ? 2 : 1;
       continue;
     }
     if (arg === "--cwd") {
@@ -1992,7 +2011,7 @@ async function handleStorageCommand(argv) {
 }
 
 export async function main(argv = process.argv.slice(2)) {
-  if (argv[0] === "help" || argv.includes("--help") || argv.includes("-h")) {
+  if (argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
     printUsage();
     return;
   }
@@ -2268,7 +2287,7 @@ export async function main(argv = process.argv.slice(2)) {
       const parsedResumeOptions = parseArgs(resumeOptions.optionArgv);
       exitOnUnknownOptions(parsedResumeOptions);
       const webLaunch = await maybeEnsureDefaultWebApp(parsedResumeOptions, { commandCwd });
-      await startInteractiveCli(agentDefaults({ ...parsedResumeOptions, resume: sessionId, commandCwd: parsedResumeOptions.commandCwd || commandCwd }), {
+      await startInteractiveCli(agentDefaults({ ...parsedResumeOptions, language: parsedResumeOptions.language || stripped.options.language, resume: sessionId, commandCwd: parsedResumeOptions.commandCwd || commandCwd }), {
         packageDir,
         packageVersion: packageJson.version,
         webAppUrl: webLaunch.ok ? webLaunch.url : "",
@@ -2278,7 +2297,7 @@ export async function main(argv = process.argv.slice(2)) {
     }
     const parsedResumeArgs = parseArgs([...resumeOptions.optionArgv, prompt]);
     exitOnUnknownOptions(parsedResumeArgs);
-    const resumeArgs = agentDefaults({ ...parsedResumeArgs, resume: sessionId, goal: prompt, commandCwd: parsedResumeArgs.commandCwd || commandCwd });
+    const resumeArgs = agentDefaults({ ...parsedResumeArgs, language: parsedResumeArgs.language || stripped.options.language, resume: sessionId, goal: prompt, commandCwd: parsedResumeArgs.commandCwd || commandCwd });
     if (!(await ensureDeepSeekKeyForOneShot(resumeArgs))) process.exit(1);
     await maybeEnsureDefaultWebApp(resumeArgs, { commandCwd });
     const config = loadConfig(resumeArgs, { packageDir });
@@ -2287,7 +2306,7 @@ export async function main(argv = process.argv.slice(2)) {
   }
 
   const parsedArgs = parseArgs(commandArgv);
-  const args = { ...parsedArgs, commandCwd: parsedArgs.commandCwd || commandCwd };
+  const args = { ...parsedArgs, language: parsedArgs.language || stripped.options.language, commandCwd: parsedArgs.commandCwd || commandCwd };
   exitOnUnknownOptions(args);
 
   if (args.webapp) {

package/src/project.js

@@ -52,6 +52,16 @@ const LOCAL_ENV_KEYS = new Set([
   "AGINTI_WRAPPER_REASONING",
   "AGINTI_AUX_PROVIDER",
   "AGINTI_AUX_MODEL",
+  "AGINTI_WRITING_PROVIDER",
+  "AGINTI_WRITING_MODEL",
+  "AGINTI_WRITING_PROVIDER_ZH",
+  "AGINTI_WRITING_MODEL_ZH",
+  "AGINTI_WRITING_PROVIDER_EN",
+  "AGINTI_WRITING_MODEL_EN",
+  "AGINTI_WRITING_PROVIDER_JA",
+  "AGINTI_WRITING_MODEL_JA",
+  "AGINTI_WRITING_PROVIDER_KO",
+  "AGINTI_WRITING_MODEL_KO",
   "QWEN_API_KEY",
   "QWEN_DEFAULT_MODEL",
   "QWEN_BASE_URL",

package/src/scs-controller.js

@@ -211,6 +211,7 @@ function fallbackHardContractPlan(goal = "", contract = {}, studentReason = "")
   const exactInputPaths = normalizeStringList(contract.exactInputPaths, []);
   const requiredTextTerms = normalizeStringList(contract.requiredTextTerms, []);
   const forbiddenTextTerms = normalizeStringList(contract.forbiddenTextTerms, []);
+  const requiredToolCalls = normalizeStringList(contract.requiredToolCalls, []);
   return [
     "1. Execute the user's target work under the deterministic hard-contract fallback plan.",
     exactOutputPaths.length
@@ -219,9 +220,10 @@ function fallbackHardContractPlan(goal = "", contract = {}, studentReason = "")
     exactInputPaths.length ? `3. Use these exact user-specified input/reference path(s): ${exactInputPaths.join(", ")}.` : "",
     requiredTextTerms.length ? `4. Ensure the output contains these required term(s): ${requiredTextTerms.join(", ")}.` : "",
     forbiddenTextTerms.length ? `5. Ensure the output does not contain these forbidden term(s): ${forbiddenTextTerms.join(", ")}.` : "",
-    "6. Run concrete validation commands or inspections for file existence and content before finish.",
-    studentReason ? `7. Preserve the validator concern while executing: ${compact(studentReason, 180)}` : "",
-    goal ? `8. Original goal remains authoritative: ${compact(goal, 220)}` : "",
+    requiredToolCalls.length ? `6. Call these explicitly required tool(s) before finish: ${requiredToolCalls.join(", ")}.` : "",
+    "7. Run concrete validation commands or inspections for file existence and content before finish.",
+    studentReason ? `8. Preserve the validator concern while executing: ${compact(studentReason, 180)}` : "",
+    goal ? `9. Original goal remains authoritative: ${compact(goal, 220)}` : "",
   ]
     .filter(Boolean)
     .join("\n");

package/src/scs-evidence.js

@@ -457,6 +457,33 @@ function inferForbiddenActions(goal = "") {
   return unique(forbidden).slice(0, 8);
 }
 
+function inferRequiredToolCalls(goal = "") {
+  const source = stripForbiddenLanguage(String(goal || ""));
+  const knownTools = [
+    "writing_specialist",
+    "json_specialist",
+    "read_image",
+    "generate_image",
+    "send_to_canvas",
+    "start_long_job",
+    "long_job_status",
+  ];
+  const required = [];
+  for (const toolName of knownTools) {
+    const index = source.indexOf(toolName);
+    if (index < 0) continue;
+    const window = source.slice(Math.max(0, index - 90), Math.min(source.length, index + toolName.length + 90));
+    const strongToolInstruction =
+      /\b(?:must|explicitly|again|call|invoke|require(?:d|s)?\s+(?:tool|call|use))\b/i.test(window) ||
+      /必须(?:调用|使用)|必須(?:調用|使用)|明确(?:调用|使用)|明確(?:調用|使用)|再次(?:调用|使用)|调用|調用/.test(window);
+    const specialistUseInstruction = /_specialist$/.test(toolName) && (/\buse\b/i.test(window) || /使用/.test(window));
+    if (strongToolInstruction || specialistUseInstruction) {
+      required.push(toolName);
+    }
+  }
+  return unique(required).slice(0, 8);
+}
+
 function stripForbiddenLanguage(goal = "") {
   return String(goal || "")
     .replace(/\b(do not|don't|dont|never|no need to|without)\s+([^.\n;]+)/gi, "")
@@ -466,7 +493,8 @@ function stripForbiddenLanguage(goal = "") {
 
 export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceCriteria = [] } = {}) {
   const requirementCategories = inferRequirementCategories(goal, taskProfile, acceptanceCriteria);
-  const requiresExternalEvidence = requirementCategories.length > 0 || goalRequiresEvidence(goal, taskProfile);
+  const requiredToolCalls = inferRequiredToolCalls(goal);
+  const requiresExternalEvidence = requirementCategories.length > 0 || requiredToolCalls.length > 0 || goalRequiresEvidence(goal, taskProfile);
   const requiredEvidence = requirementCategories.map((category) => ({
     id: category,
     category,
@@ -483,6 +511,7 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
     forbiddenActions: inferForbiddenActions(goal),
     exactOutputPaths,
     exactInputPaths,
+    requiredToolCalls,
     requiredTextTerms: inferRequiredTextTerms(goal),
     forbiddenTextTerms: inferForbiddenTextTerms(goal),
     successCriteria: unique(acceptanceCriteria).slice(0, 10),
@@ -679,6 +708,7 @@ export function buildScsEvidenceLedger({ state = {}, context = {} } = {}) {
   const messageEvidence = messages.flatMap(messageToEvidence);
   const items = [...eventEvidence, ...messageEvidence].slice(-80);
   const categories = unique(items.map((item) => item.category));
+  const toolNames = unique(items.map((item) => item.toolName).filter(Boolean));
   const blockers = [...events.map(eventToBlocker), ...messages.map(messageToBlocker)]
     .filter(Boolean)
     .slice(-20)
@@ -690,6 +720,7 @@ export function buildScsEvidenceLedger({ state = {}, context = {} } = {}) {
     version: 1,
     itemCount: items.length,
     categories,
+    toolNames,
     blockerCount: blockers.length,
     blockers,
     items: items.map((item, index) => ({
@@ -702,6 +733,8 @@ export function buildScsEvidenceLedger({ state = {}, context = {} } = {}) {
 export function evaluateScsEvidence(contract = {}, ledger = {}) {
   const required = Array.isArray(contract.requiredEvidence) ? contract.requiredEvidence : [];
   const ledgerCategories = new Set(Array.isArray(ledger.categories) ? ledger.categories : []);
+  const requiredToolCalls = Array.isArray(contract.requiredToolCalls) ? contract.requiredToolCalls : [];
+  const ledgerToolNames = new Set(Array.isArray(ledger.toolNames) ? ledger.toolNames : []);
   const satisfied = [];
   const missing = [];
   for (const requirement of required) {
@@ -711,17 +744,23 @@ export function evaluateScsEvidence(contract = {}, ledger = {}) {
       missing.push(requirement);
     }
   }
+  const missingToolCalls = requiredToolCalls.filter((toolName) => !ledgerToolNames.has(toolName));
   const hasAnyEvidence = Number(ledger.itemCount || 0) > 0;
-  const ok = !contract.requiresExternalEvidence || (missing.length === 0 && hasAnyEvidence);
+  const evidenceOk = !contract.requiresExternalEvidence || (missing.length === 0 && hasAnyEvidence);
+  const ok = evidenceOk && missingToolCalls.length === 0;
   return {
     ok,
     requiresExternalEvidence: Boolean(contract.requiresExternalEvidence),
     hasAnyEvidence,
     satisfied,
     missing,
+    requiredToolCalls,
+    missingToolCalls,
     reason: ok
       ? "Evidence satisfies the deterministic task contract."
-      : missing.length
+      : missingToolCalls.length
+        ? `Missing required tool calls: ${missingToolCalls.join(", ")}.`
+        : missing.length
         ? `Missing evidence categories: ${missing.map((item) => item.category).join(", ")}.`
         : "Task requires external evidence but the ledger is empty.",
   };
@@ -741,6 +780,7 @@ export function summarizeScsContractEvidence({ contract = {}, ledger = {}, evalu
       forbiddenActions: contract.forbiddenActions || [],
       exactOutputPaths: contract.exactOutputPaths || [],
       exactInputPaths: contract.exactInputPaths || [],
+      requiredToolCalls: contract.requiredToolCalls || [],
       requiredTextTerms: contract.requiredTextTerms || [],
       forbiddenTextTerms: contract.forbiddenTextTerms || [],
       successCriteria: contract.successCriteria || [],
@@ -748,6 +788,7 @@ export function summarizeScsContractEvidence({ contract = {}, ledger = {}, evalu
     evidenceLedger: {
       itemCount: ledger.itemCount || 0,
       categories: ledger.categories || [],
+      toolNames: ledger.toolNames || [],
       recentItems: (ledger.items || []).slice(-12).map((item) => ({
         id: item.id,
         category: item.category,
@@ -770,6 +811,7 @@ export function summarizeScsContractEvidence({ contract = {}, ledger = {}, evalu
       ok: Boolean(evaluation.ok),
       reason: evaluation.reason || "",
       missing: (evaluation.missing || []).map((item) => item.category),
+      missingToolCalls: evaluation.missingToolCalls || [],
       satisfied: (evaluation.satisfied || []).map((item) => item.category),
     },
   };
@@ -794,6 +836,7 @@ export function deterministicFinishBlocker(contract = {}, ledger = {}, evaluatio
     evidence: [
       `Required: ${(contract.requiredEvidence || []).map((item) => item.category).join(", ") || "external evidence"}`,
       `Present: ${(ledger.categories || []).join(", ") || "none"}`,
+      ...(evaluation.missingToolCalls?.length ? [`Required tool calls missing: ${evaluation.missingToolCalls.join(", ")}`] : []),
     ],
     nextRequiredAction:
       "Collect the missing concrete evidence, verify the requested state or artifact, then ask SCS to finish again; if impossible, report a real blocker with proof.",

package/src/workspace-tools.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { XMLValidator } from "fast-xml-parser";
 import { hasSensitiveText, redactSensitiveText } from "./redaction.js";
 
 export const WORKSPACE_TOOL_NAMES = ["inspect_project", "list_files", "read_file", "search_files", "write_file", "apply_patch"];
@@ -174,6 +175,13 @@ function validateSvgArtifact(relativePath, content) {
   const cdataOpen = (trimmed.match(/<!\[CDATA\[/gi) || []).length;
   const cdataClose = (trimmed.match(/\]\]>/g) || []).length;
   if (cdataOpen !== cdataClose) errors.push("CDATA open/close markers are unbalanced.");
+  const xmlValidation = trimmed ? XMLValidator.validate(trimmed, { allowBooleanAttributes: false }) : true;
+  if (xmlValidation !== true) {
+    const err = xmlValidation?.err || {};
+    errors.push(
+      `XML parser rejected SVG${err.line ? ` at line ${err.line}${err.col ? `:${err.col}` : ""}` : ""}: ${err.msg || "invalid XML syntax"}`
+    );
+  }
   errors.push(...validateXmlTagStack(trimmed));
   if (/<text\b/i.test(trimmed) && !/(viewBox|width|height)=/i.test(trimmed)) {
     warnings.push("SVG contains text but no obvious sizing/viewBox metadata; render-preview before claiming visual fit.");
@@ -181,7 +189,7 @@ function validateSvgArtifact(relativePath, content) {
   return {
     kind: "svg",
     ok: errors.length === 0,
-    parser: "builtin-svg-xml-guard",
+    parser: "fast-xml-parser+xml-stack-guard",
     root: root || "",
     errors,
     warnings,

package/src/writing-specialist.js

@@ -87,8 +87,62 @@ function normalizeWritingRequest(args = {}) {
     length: normalizeText(args.length || args.targetLength || ""),
     formatIntent: normalizeText(args.formatIntent || args.outputFormat || ""),
     temperature: normalizeTemperature(args.temperature, kind),
-    provider: String(args.provider || process.env.AGINTI_WRITING_PROVIDER || "").trim(),
-    model: String(args.model || process.env.AGINTI_WRITING_MODEL || "").trim(),
+    provider: String(args.provider || "").trim(),
+    model: String(args.model || "").trim(),
+  };
+}
+
+function likelyLanguageFromText(request = {}) {
+  const explicit = String(request.language || "").trim();
+  if (explicit) return explicit;
+  const text = [request.writingBrief, request.target, request.audience, request.canon, request.styleGuide, request.priorDraft, request.constraints]
+    .join("\n")
+    .slice(0, 8000);
+  if (/[\u3040-\u30ff]/.test(text)) return "ja";
+  if (/[\uac00-\ud7af]/.test(text)) return "ko";
+  if (/[\u4e00-\u9fff]/.test(text)) return "zh-Hans";
+  return "en";
+}
+
+function languageEnvSuffix(language = "") {
+  const normalized = String(language || "").toLowerCase();
+  if (normalized.startsWith("zh")) return "ZH";
+  if (normalized.startsWith("ja")) return "JA";
+  if (normalized.startsWith("ko")) return "KO";
+  if (normalized.startsWith("en")) return "EN";
+  return "";
+}
+
+function hasProviderKey(provider = "") {
+  const normalized = String(provider || "").toLowerCase();
+  if (normalized === "openai") return Boolean(process.env.OPENAI_API_KEY || process.env.LLM_API_KEY);
+  if (normalized === "deepseek") return Boolean(process.env.DEEPSEEK_API_KEY || process.env.LLM_API_KEY);
+  if (normalized === "openrouter") return Boolean(process.env.OPENROUTER_API_KEY);
+  if (normalized === "qwen") return Boolean(process.env.QWEN_API_KEY);
+  if (normalized === "venice") return Boolean(process.env.VENICE_API_KEY);
+  if (normalized === "mock") return true;
+  return false;
+}
+
+export function languageWriterDefaults(request = {}, config = {}) {
+  const language = likelyLanguageFromText(request);
+  const suffix = languageEnvSuffix(language);
+  const envProvider = String((suffix && process.env[`AGINTI_WRITING_PROVIDER_${suffix}`]) || process.env.AGINTI_WRITING_PROVIDER || "").trim();
+  const envModel = String((suffix && process.env[`AGINTI_WRITING_MODEL_${suffix}`]) || process.env.AGINTI_WRITING_MODEL || "").trim();
+  if (envProvider || envModel) {
+    return { provider: envProvider, model: envModel, language, reason: "writer-env" };
+  }
+  if (String(language || "").toLowerCase().startsWith("zh") && hasProviderKey("deepseek")) {
+    return { provider: "deepseek", model: process.env.DEEPSEEK_PRO_MODEL || "deepseek-v4-pro", language, reason: "zh-deepseek-default" };
+  }
+  if (String(language || "").toLowerCase().startsWith("en") && hasProviderKey("openai")) {
+    return { provider: "openai", model: process.env.OPENAI_DEFAULT_MODEL || process.env.LLM_MODEL || "gpt-5.4", language, reason: "en-openai-default" };
+  }
+  return {
+    provider: config.provider || "",
+    model: config.model || "",
+    language,
+    reason: "session-default",
   };
 }
 
@@ -193,8 +247,9 @@ export async function runWritingSpecialist(args = {}, config = {}, store = null)
     .update(JSON.stringify(redactValue(request)))
     .digest("hex");
   let result;
-  let model = request.model || config.model || "";
-  let provider = request.provider || config.provider || "";
+  const writerDefaults = languageWriterDefaults(request, config);
+  let model = request.model || writerDefaults.model || config.model || "";
+  let provider = request.provider || writerDefaults.provider || config.provider || "";
   let rawContent = "";
 
   try {
@@ -204,11 +259,13 @@ export async function runWritingSpecialist(args = {}, config = {}, store = null)
       result = mockWritingResult(request);
     } else {
       const providerDefaults = request.provider ? getProviderDefaults(request.provider) : {};
+      const selectedProviderDefaults = provider ? getProviderDefaults(provider) : {};
       const writingConfig = {
         ...config,
+        ...selectedProviderDefaults,
         ...providerDefaults,
         provider: provider || config.provider,
-        model: model || providerDefaults.model || config.model,
+        model: model || providerDefaults.model || selectedProviderDefaults.model || config.model,
       };
       model = writingConfig.model;
       provider = writingConfig.provider;
@@ -254,9 +311,11 @@ export async function runWritingSpecialist(args = {}, config = {}, store = null)
         task: request.task,
         kind: request.kind,
         language: request.language,
+        detectedLanguage: writerDefaults.language,
         target: request.target,
         length: request.length,
         provider: request.provider,
+        routeReason: writerDefaults.reason,
         formatIntent: request.formatIntent,
         requestFingerprint,
       },
@@ -273,8 +332,10 @@ export async function runWritingSpecialist(args = {}, config = {}, store = null)
         task: request.task,
         kind: request.kind,
         language: request.language,
+        detectedLanguage: writerDefaults.language,
         target: request.target,
         provider: request.provider,
+        routeReason: writerDefaults.reason,
         requestFingerprint,
       },
       error: redactSensitiveText(error instanceof Error ? error.message : String(error)),