@rex0220/llm-task-router 0.1.0

package/dist/llm-task-router.js

@@ -0,0 +1,1465 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "dotenv/config";
+import { readFileSync } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import { basename as basename3 } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/cli/inputs.ts
+import { readFile } from "fs/promises";
+import { basename, resolve, sep } from "path";
+function assertSafeInputPath(filePath, cwd = process.cwd()) {
+  const name = basename(filePath).toLowerCase();
+  if (name === ".env" || name.startsWith(".env.")) {
+    throw new Error(`Refusing to read a secret file: ${filePath}`);
+  }
+  const resolved = resolve(cwd, filePath);
+  const root = resolve(cwd);
+  if (resolved !== root && !resolved.startsWith(`${root}${sep}`)) {
+    process.stderr.write(`Warning: reading a file outside the workspace: ${resolved}
+`);
+  }
+}
+function assertSafeOutputPath(filePath, cwd = process.cwd()) {
+  const name = basename(filePath).toLowerCase();
+  if (name === ".env" || name.startsWith(".env.")) {
+    throw new Error(`Refusing to write to a secret file: ${filePath}`);
+  }
+  const resolved = resolve(cwd, filePath);
+  const root = resolve(cwd);
+  if (resolved !== root && !resolved.startsWith(`${root}${sep}`)) {
+    process.stderr.write(`Warning: writing a file outside the workspace: ${resolved}
+`);
+  }
+}
+async function resolveText(inline, filePath, label, inlineFlag, fileFlag) {
+  if (inline !== void 0 && filePath !== void 0) {
+    throw new Error(`Specify only one of ${inlineFlag} or ${fileFlag}, not both`);
+  }
+  if (filePath !== void 0) {
+    assertSafeInputPath(filePath);
+    const content = (await readFile(filePath, "utf8")).trim();
+    if (!content) {
+      throw new Error(`${label} file is empty: ${filePath}`);
+    }
+    return content;
+  }
+  const text = inline?.trim();
+  if (text) {
+    return text;
+  }
+  throw new Error(`Provide ${label} with ${inlineFlag} "..." or ${fileFlag} <path>`);
+}
+
+// src/cli/export.ts
+import { access, mkdir, writeFile } from "fs/promises";
+import { dirname, resolve as resolve2 } from "path";
+async function exportFinalArticle(store, runId, outPath, options = {}) {
+  const content = await store.read(runId, "final.md");
+  assertSafeOutputPath(outPath);
+  const resolved = resolve2(outPath);
+  if (!options.force) {
+    const exists2 = await access(resolved).then(
+      () => true,
+      () => false
+    );
+    if (exists2) {
+      throw new Error(`Output already exists: ${resolved} (use --force to overwrite)`);
+    }
+  }
+  await mkdir(dirname(resolved), { recursive: true });
+  await writeFile(resolved, content, "utf8");
+  return resolved;
+}
+
+// src/cli/init.ts
+import { access as access2, copyFile, mkdir as mkdir2, readdir } from "fs/promises";
+import { dirname as dirname2, join, relative } from "path";
+async function exists(path) {
+  return access2(path).then(
+    () => true,
+    () => false
+  );
+}
+async function listFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles(full));
+    } else {
+      files.push(full);
+    }
+  }
+  return files;
+}
+async function initConfig(targetDir, sourceDir, options = {}) {
+  const created = [];
+  const skipped = [];
+  const sources = await listFiles(join(sourceDir, "config"));
+  const envExample = join(sourceDir, ".env.example");
+  if (await exists(envExample)) {
+    sources.push(envExample);
+  }
+  for (const src of sources) {
+    const rel = relative(sourceDir, src);
+    const dest = join(targetDir, rel);
+    if (!options.force && await exists(dest)) {
+      skipped.push(rel);
+      continue;
+    }
+    await mkdir2(dirname2(dest), { recursive: true });
+    await copyFile(src, dest);
+    created.push(rel);
+  }
+  return { created, skipped };
+}
+
+// src/workflows/profile.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename2, join as join2 } from "path";
+import { parse } from "yaml";
+import { z } from "zod";
+
+// src/router/errors.ts
+var RouterError = class extends Error {
+  kind;
+  statusCode;
+  constructor(message, kind, statusCode) {
+    super(message);
+    this.name = "RouterError";
+    this.kind = kind;
+    this.statusCode = statusCode;
+  }
+};
+function isRouterError(error) {
+  return error instanceof RouterError;
+}
+function normalizeProviderError(error) {
+  if (isRouterError(error)) {
+    return error;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return new RouterError("Provider request was aborted", "timeout");
+  }
+  const maybeError = error;
+  const statusCode = toNumber(maybeError.status ?? maybeError.statusCode);
+  const code = toLowerString(maybeError.code);
+  const type = toLowerString(maybeError.type);
+  const name = toLowerString(maybeError.name);
+  const message = safeMessage(maybeError.message ?? String(error));
+  const haystack = `${name} ${code} ${type}`;
+  if (statusCode === 401 || statusCode === 403 || includesAny(haystack, ["authentication", "permission", "auth"])) {
+    return new RouterError(message, "auth", statusCode);
+  }
+  if (includesAny(haystack, ["insufficient_quota", "billing", "payment", "credit"])) {
+    return new RouterError(message, "billing_quota", statusCode);
+  }
+  if (statusCode === 429 || includesAny(haystack, ["rate_limit", "ratelimit"])) {
+    return new RouterError(message, "rate_limit", statusCode);
+  }
+  if (includesAny(haystack, ["timeout", "timedout", "abort"])) {
+    return new RouterError(message, "timeout", statusCode);
+  }
+  if (statusCode === 529 || includesAny(haystack, ["overloaded"])) {
+    return new RouterError(message, "overloaded", statusCode);
+  }
+  if (statusCode === 503 || statusCode === 502 || statusCode === 504) {
+    return new RouterError(message, "service_unavailable", statusCode);
+  }
+  if (statusCode && statusCode >= 500) {
+    return new RouterError(message, "service_unavailable", statusCode);
+  }
+  if (includesAny(haystack, ["connection", "network", "fetch", "econnreset", "enotfound"])) {
+    return new RouterError(message, "connection", statusCode);
+  }
+  if (statusCode === 400 || includesAny(haystack, ["badrequest", "bad_request", "invalid_request"])) {
+    return new RouterError(message, "bad_request", statusCode);
+  }
+  if (includesAny(haystack, ["context_length", "too_large", "token"])) {
+    return new RouterError(message, "context_length", statusCode);
+  }
+  return new RouterError(message, "unknown", statusCode);
+}
+function shouldFallback(kind) {
+  return [
+    "rate_limit",
+    "timeout",
+    "overloaded",
+    "service_unavailable",
+    "connection",
+    "schema_validation"
+  ].includes(kind);
+}
+function errorForLog(error) {
+  const normalized = normalizeProviderError(error);
+  return {
+    kind: normalized.kind,
+    message: safeMessage(normalized.message),
+    statusCode: normalized.statusCode
+  };
+}
+function includesAny(value, needles) {
+  return needles.some((needle) => value.includes(needle));
+}
+function toLowerString(value) {
+  return typeof value === "string" ? value.toLowerCase() : "";
+}
+function toNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function safeMessage(value) {
+  const text = typeof value === "string" ? value : "Provider request failed";
+  return text.replace(/sk-[A-Za-z0-9_-]+/g, "[redacted]").slice(0, 300);
+}
+
+// src/workflows/profile.ts
+var profileSchema = z.object({
+  platform: z.string().min(1),
+  language: z.string().optional(),
+  style: z.string().optional(),
+  criteria_file: z.string().optional()
+});
+async function loadProfile(name, dir = "config/profiles") {
+  if (!/^[A-Za-z0-9._-]+$/.test(name) || name.includes("..")) {
+    throw new RouterError(`Invalid profile name: ${name}`, "config");
+  }
+  const path = join2(dir, `${basename2(name)}.yaml`);
+  let raw;
+  try {
+    raw = await readFile2(path, "utf8");
+  } catch {
+    throw new RouterError(`Profile not found: ${name} (expected ${path})`, "config");
+  }
+  const parsed = profileSchema.safeParse(parse(raw));
+  if (!parsed.success) {
+    throw new RouterError(`Invalid profile ${name}: ${parsed.error.message}`, "config");
+  }
+  return {
+    platform: parsed.data.platform,
+    language: parsed.data.language,
+    style: parsed.data.style?.trim() || void 0,
+    criteriaFile: parsed.data.criteria_file?.trim() || void 0
+  };
+}
+
+// src/logger/RunLogger.ts
+import { mkdir as mkdir3, appendFile } from "fs/promises";
+import { dirname as dirname3 } from "path";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function sha256(text) {
+  return `sha256:${createHash("sha256").update(text).digest("hex")}`;
+}
+
+// src/logger/RunLogger.ts
+var RunLogger = class {
+  constructor(logPath = "runs/router.log") {
+    this.logPath = logPath;
+  }
+  logPath;
+  async logSuccess(request, response) {
+    await this.append({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      task: request.task,
+      provider: response.provider,
+      model: response.model,
+      status: "success",
+      input_hash: sha256(request.input),
+      elapsed_ms: response.elapsedMs,
+      input_tokens: response.usage?.inputTokens,
+      output_tokens: response.usage?.outputTokens,
+      cost_usd: response.usage?.costUsd
+    });
+  }
+  async logFailure(request, candidate, error) {
+    const normalized = errorForLog(error);
+    await this.append({
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      task: request.task,
+      provider: candidate.provider,
+      model: candidate.model,
+      status: "failure",
+      input_hash: sha256(request.input),
+      error_kind: normalized.kind,
+      error_message: normalized.message,
+      status_code: normalized.statusCode
+    });
+  }
+  async append(entry) {
+    await mkdir3(dirname3(this.logPath), { recursive: true });
+    await appendFile(this.logPath, `${JSON.stringify(withoutUndefined(entry))}
+`, "utf8");
+  }
+};
+function withoutUndefined(entry) {
+  return Object.fromEntries(Object.entries(entry).filter(([, value]) => value !== void 0));
+}
+
+// src/router/config.ts
+import { readFile as readFile3 } from "fs/promises";
+import { parse as parse2 } from "yaml";
+import { z as z2 } from "zod";
+var modelTaskSchema = z2.enum([
+  "article_brief",
+  "outline",
+  "draft_markdown",
+  "technical_review",
+  "final_review",
+  "rewrite",
+  "markdown_format",
+  "title_suggestions"
+]);
+var candidateSchema = z2.object({
+  provider: z2.string().min(1),
+  model: z2.string().min(1)
+});
+var taskConfigSchema = z2.object({
+  primary: candidateSchema,
+  fallback: z2.array(candidateSchema).optional(),
+  temperature: z2.number().optional(),
+  max_tokens: z2.number().int().positive().optional(),
+  timeout_ms: z2.number().int().positive().optional()
+});
+var routerConfigSchema = z2.object({
+  providers: z2.record(z2.object({ api_key_env: z2.string().min(1).optional() })).default({}),
+  prices: z2.record(
+    z2.record(
+      z2.object({
+        input_usd_per_1m_tokens: z2.number().nonnegative().optional(),
+        output_usd_per_1m_tokens: z2.number().nonnegative().optional()
+      })
+    )
+  ).default({}),
+  defaults: z2.object({ timeout_ms: z2.number().int().positive().default(12e4) }).default({ timeout_ms: 12e4 }),
+  tasks: z2.record(modelTaskSchema, taskConfigSchema)
+});
+async function loadRouterConfig(path = "config/models.yaml") {
+  const raw = await readFile3(path, "utf8");
+  const parsed = routerConfigSchema.safeParse(parse2(raw));
+  if (!parsed.success) {
+    throw new RouterError(`Invalid router config: ${parsed.error.message}`, "config");
+  }
+  const config = parsed.data;
+  for (const [task, taskConfig] of Object.entries(config.tasks)) {
+    if (!taskConfig.primary) {
+      throw new RouterError(`Task ${task} is missing primary model`, "config");
+    }
+  }
+  return config;
+}
+function resolveApiKeyEnv(providerName, config) {
+  const configured = config.providers[providerName]?.api_key_env;
+  if (configured) {
+    return configured;
+  }
+  switch (providerName) {
+    case "openai":
+      return "OPENAI_API_KEY";
+    case "anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "gemini":
+      return "GEMINI_API_KEY";
+    default:
+      return `${providerName.toUpperCase()}_API_KEY`;
+  }
+}
+
+// src/providers/AnthropicProvider.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  client;
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new RouterError("Anthropic API key is not configured", "auth");
+    }
+    this.client = new Anthropic({
+      apiKey,
+      maxRetries: options.maxRetries ?? 2,
+      timeout: options.timeoutMs
+    });
+  }
+  async generate(request) {
+    const body = {
+      model: request.model,
+      max_tokens: request.maxTokens ?? 4e3,
+      messages: [{ role: "user", content: request.input }]
+    };
+    if (request.system) {
+      body.system = request.system;
+    }
+    if (supportsTemperature(request.model) && request.temperature !== void 0) {
+      body.temperature = request.temperature;
+    }
+    const response = await this.client.messages.create(body, {
+      signal: request.abortSignal
+    });
+    return {
+      text: extractAnthropicText(response),
+      usage: response.usage ? {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens
+      } : void 0,
+      truncated: response.stop_reason === "max_tokens"
+    };
+  }
+};
+function supportsTemperature(model) {
+  const normalized = model.toLowerCase();
+  return !(normalized.includes("opus") || normalized.includes("sonnet-4") || normalized.includes("haiku-4") || normalized.includes("fable"));
+}
+function extractAnthropicText(response) {
+  const content = response.content;
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((block) => {
+    const text = block.text;
+    return typeof text === "string" ? text : "";
+  }).filter(Boolean).join("\n");
+}
+
+// src/providers/OpenAIProvider.ts
+import OpenAI from "openai";
+var OpenAIProvider = class {
+  client;
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new RouterError("OpenAI API key is not configured", "auth");
+    }
+    this.client = new OpenAI({
+      apiKey,
+      maxRetries: options.maxRetries ?? 2,
+      timeout: options.timeoutMs
+    });
+  }
+  async generate(request) {
+    const body = {
+      model: request.model,
+      input: request.input
+    };
+    if (request.system) {
+      body.instructions = request.system;
+    }
+    if (request.maxTokens) {
+      body.max_output_tokens = request.maxTokens;
+    }
+    if (supportsOpenAITemperature(request.model) && request.temperature !== void 0) {
+      body.temperature = request.temperature;
+    }
+    if (request.responseFormat?.type === "json_schema") {
+      body.text = { format: { type: "json_object" } };
+    }
+    const response = await this.client.responses.create(body, {
+      signal: request.abortSignal
+    });
+    const usage = response.usage ? {
+      inputTokens: response.usage.input_tokens,
+      outputTokens: response.usage.output_tokens
+    } : void 0;
+    return {
+      text: extractOpenAIText(response),
+      usage,
+      truncated: isOpenAITruncated(response)
+    };
+  }
+};
+function isOpenAITruncated(response) {
+  const r = response;
+  return r.status === "incomplete" && r.incomplete_details?.reason === "max_output_tokens";
+}
+function supportsOpenAITemperature(model) {
+  const normalized = model.toLowerCase();
+  return !(normalized.startsWith("o") || normalized.startsWith("gpt-5") || normalized.includes("reasoning"));
+}
+function extractOpenAIText(response) {
+  const outputText = response.output_text;
+  if (typeof outputText === "string") {
+    return outputText;
+  }
+  const output = response.output;
+  if (Array.isArray(output)) {
+    const parts = [];
+    for (const item of output) {
+      const content = item.content;
+      if (!Array.isArray(content)) {
+        continue;
+      }
+      for (const block of content) {
+        const text = block.text;
+        if (typeof text === "string") {
+          parts.push(text);
+        }
+      }
+    }
+    if (parts.length > 0) {
+      return parts.join("\n");
+    }
+  }
+  return "";
+}
+
+// src/providers/index.ts
+function createProviders(config, env = process.env) {
+  const providers = {};
+  if (hasProviderReference(config, "openai")) {
+    const keyEnv = resolveApiKeyEnv("openai", config);
+    const apiKey = env[keyEnv] || env.OPENAI_API_KEY;
+    if (apiKey) {
+      providers.openai = new OpenAIProvider(apiKey);
+    }
+  }
+  if (hasProviderReference(config, "anthropic")) {
+    const keyEnv = resolveApiKeyEnv("anthropic", config);
+    const apiKey = env[keyEnv] || env.ANTHROPIC_API_KEY;
+    if (apiKey) {
+      providers.anthropic = new AnthropicProvider(apiKey);
+    }
+  }
+  return providers;
+}
+function hasProviderReference(config, provider) {
+  return Object.values(config.tasks).some(
+    (task) => task.primary.provider === provider || task.fallback?.some((candidate) => candidate.provider === provider)
+  );
+}
+
+// src/schemas/ArticleBriefSchema.ts
+import { z as z3 } from "zod";
+var ArticleBriefSchema = z3.object({
+  title: z3.string(),
+  targetReaders: z3.array(z3.string()),
+  goal: z3.array(z3.string()),
+  mainClaim: z3.string(),
+  sections: z3.array(
+    z3.object({
+      heading: z3.string(),
+      points: z3.array(z3.string())
+    })
+  ),
+  codeExamples: z3.array(
+    z3.object({
+      language: z3.string(),
+      purpose: z3.string()
+    })
+  )
+});
+
+// src/schemas/ArticleOutlineSchema.ts
+import { z as z4 } from "zod";
+var ArticleOutlineSchema = z4.object({
+  title: z4.string(),
+  introduction: z4.string().optional(),
+  sections: z4.array(
+    z4.object({
+      heading: z4.string(),
+      summary: z4.string().optional(),
+      points: z4.array(z4.string()).default([]),
+      codeExample: z4.object({
+        language: z4.string(),
+        purpose: z4.string()
+      }).optional()
+    })
+  ),
+  conclusion: z4.string().optional()
+});
+
+// src/schemas/ReviewResultSchema.ts
+import { z as z5 } from "zod";
+var ReviewResultSchema = z5.object({
+  summary: z5.string(),
+  issues: z5.array(
+    z5.object({
+      severity: z5.enum(["critical", "major", "minor", "suggestion"]),
+      location: z5.string().optional(),
+      problem: z5.string(),
+      recommendation: z5.string()
+    })
+  ),
+  approved: z5.boolean().optional()
+});
+
+// src/schemas/index.ts
+var schemaRegistry = {
+  ArticleBrief: ArticleBriefSchema,
+  ArticleOutline: ArticleOutlineSchema,
+  ReviewResult: ReviewResultSchema
+};
+var schemaHints = {
+  ArticleBrief: `{
+  "title": "string",
+  "targetReaders": ["string"],
+  "goal": ["string"],
+  "mainClaim": "string",
+  "sections": [{ "heading": "string", "points": ["string"] }],
+  "codeExamples": [{ "language": "string", "purpose": "string" }]
+}`,
+  ArticleOutline: `{
+  "title": "string",
+  "introduction": "string (\u4EFB\u610F)",
+  "sections": [{
+    "heading": "string",
+    "summary": "string (\u4EFB\u610F)",
+    "points": ["string"],
+    "codeExample": { "language": "string", "purpose": "string" } (\u4EFB\u610F)
+  }],
+  "conclusion": "string (\u4EFB\u610F)"
+}`,
+  ReviewResult: `{
+  "summary": "string",
+  "issues": [{
+    "severity": "critical | major | minor | suggestion",
+    "location": "string (\u4EFB\u610F)",
+    "problem": "string",
+    "recommendation": "string"
+  }],
+  "approved": "boolean (\u4EFB\u610F)"
+}`
+};
+
+// src/utils/cost.ts
+function estimateCostUsd(usage, price) {
+  if (!usage || !price) {
+    return void 0;
+  }
+  const inputRate = price.input_usd_per_1m_tokens ?? 0;
+  const outputRate = price.output_usd_per_1m_tokens ?? 0;
+  if (inputRate <= 0 && outputRate <= 0) {
+    return void 0;
+  }
+  const inputCost = (usage.inputTokens ?? 0) / 1e6 * inputRate;
+  const outputCost = (usage.outputTokens ?? 0) / 1e6 * outputRate;
+  return Number((inputCost + outputCost).toFixed(6));
+}
+
+// src/utils/json.ts
+function parseJsonObject(text) {
+  const trimmed = text.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const extracted = extractJsonCandidate(trimmed);
+    if (!extracted) {
+      throw new RouterError("Model output was not valid JSON", "schema_validation");
+    }
+    try {
+      return JSON.parse(extracted);
+    } catch {
+      throw new RouterError("Model output JSON could not be parsed", "schema_validation");
+    }
+  }
+}
+function extractJsonCandidate(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) {
+    return fenced[1].trim();
+  }
+  const firstObject = text.indexOf("{");
+  const lastObject = text.lastIndexOf("}");
+  if (firstObject >= 0 && lastObject > firstObject) {
+    return text.slice(firstObject, lastObject + 1);
+  }
+  const firstArray = text.indexOf("[");
+  const lastArray = text.lastIndexOf("]");
+  if (firstArray >= 0 && lastArray > firstArray) {
+    return text.slice(firstArray, lastArray + 1);
+  }
+  return void 0;
+}
+
+// src/utils/timeout.ts
+async function withAbortableTimeout(timeoutMs, run) {
+  const controller = new AbortController();
+  if (!timeoutMs || timeoutMs <= 0) {
+    return run(controller.signal);
+  }
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new RouterError(`Provider request timed out after ${timeoutMs}ms`, "timeout"));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([run(controller.signal), timeout]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+
+// src/router/ModelRouter.ts
+var ModelRouter = class {
+  constructor(providers, config, logger = new RunLogger()) {
+    this.providers = providers;
+    this.config = config;
+    this.logger = logger;
+  }
+  providers;
+  config;
+  logger;
+  async run(request) {
+    const taskConfig = this.config.tasks[request.task];
+    if (!taskConfig) {
+      throw new RouterError(`Task is not configured: ${request.task}`, "config");
+    }
+    if (request.schemaName && !schemaRegistry[request.schemaName]) {
+      throw new RouterError(`Schema is not registered: ${request.schemaName}`, "config");
+    }
+    const candidates = [taskConfig.primary, ...taskConfig.fallback ?? []];
+    let lastError;
+    for (const candidate of candidates) {
+      const provider = this.providers[candidate.provider];
+      if (!provider) {
+        lastError = new RouterError(`Provider is not registered: ${candidate.provider}`, "config");
+        continue;
+      }
+      try {
+        const startedAt = Date.now();
+        const providerRequest = this.buildProviderRequest(request, candidate);
+        const response = await this.callProvider(provider, providerRequest);
+        const result = this.toModelResponse(candidate, response, Date.now() - startedAt);
+        const validated = await this.validateAndMaybeRepair(provider, providerRequest, candidate, result, request.schemaName);
+        await this.logger.logSuccess(request, validated);
+        return validated;
+      } catch (error) {
+        const normalized = normalizeProviderError(error);
+        lastError = normalized;
+        await this.logger.logFailure(request, candidate, normalized);
+        if (!shouldFallback(normalized.kind)) {
+          throw normalized;
+        }
+      }
+    }
+    if (lastError) {
+      const normalized = normalizeProviderError(lastError);
+      throw new RouterError(`All model candidates failed: ${normalized.message}`, normalized.kind, normalized.statusCode);
+    }
+    throw new RouterError(`No model candidates configured for task: ${request.task}`, "config");
+  }
+  buildProviderRequest(request, candidate) {
+    const taskConfig = this.config.tasks[request.task];
+    return {
+      model: candidate.model,
+      input: request.schemaName ? withSchemaInstruction(request.input, request.schemaName) : request.input,
+      system: request.system,
+      temperature: request.temperature ?? taskConfig.temperature,
+      maxTokens: request.maxTokens ?? taskConfig.max_tokens,
+      timeoutMs: taskConfig.timeout_ms ?? this.config.defaults.timeout_ms,
+      responseFormat: request.schemaName ? { type: "json_schema", schemaName: request.schemaName } : { type: "text" }
+    };
+  }
+  async callProvider(provider, request) {
+    return withAbortableTimeout(request.timeoutMs, (abortSignal) => provider.generate({ ...request, abortSignal }));
+  }
+  toModelResponse(candidate, response, elapsedMs) {
+    const usage = response.usage ? { ...response.usage } : void 0;
+    if (usage && usage.costUsd === void 0) {
+      usage.costUsd = estimateCostUsd(usage, this.config.prices[candidate.provider]?.[candidate.model]);
+    }
+    return {
+      provider: candidate.provider,
+      model: candidate.model,
+      text: response.text,
+      usage,
+      elapsedMs,
+      truncated: response.truncated
+    };
+  }
+  async validateAndMaybeRepair(provider, originalRequest, candidate, response, schemaName) {
+    if (!schemaName) {
+      return response;
+    }
+    try {
+      return this.validateResponse(response, schemaName);
+    } catch (firstError) {
+      if (normalizeProviderError(firstError).kind !== "schema_validation") {
+        throw firstError;
+      }
+    }
+    const repairRequest = {
+      ...originalRequest,
+      input: buildRepairPrompt(schemaName, response.text),
+      temperature: 0,
+      responseFormat: { type: "json_schema", schemaName }
+    };
+    const startedAt = Date.now();
+    const repaired = await this.callProvider(provider, repairRequest);
+    const repairedResponse = this.toModelResponse(candidate, repaired, Date.now() - startedAt);
+    try {
+      return this.validateResponse(repairedResponse, schemaName);
+    } catch {
+      throw new RouterError(`Model output failed ${schemaName} validation after one repair attempt`, "schema_validation");
+    }
+  }
+  validateResponse(response, schemaName) {
+    const schema = schemaRegistry[schemaName];
+    if (!schema) {
+      throw new RouterError(`Schema is not registered: ${schemaName}`, "config");
+    }
+    const parsed = parseJsonObject(response.text);
+    const validated = schema.safeParse(parsed);
+    if (!validated.success) {
+      throw new RouterError(`Model output did not match schema ${schemaName}`, "schema_validation");
+    }
+    return {
+      ...response,
+      text: `${JSON.stringify(validated.data, null, 2)}
+`
+    };
+  }
+};
+function withSchemaInstruction(input, schemaName) {
+  return [
+    input,
+    "",
+    "\u51FA\u529B\u306F\u6B21\u306EJSON\u30B9\u30AD\u30FC\u30DE\u306B\u53B3\u5BC6\u306B\u5F93\u3063\u3066\u304F\u3060\u3055\u3044\u3002",
+    "\u6307\u5B9A\u3055\u308C\u305F\u30AD\u30FC\u306E\u307F\u3092\u542B\u3080JSON\u3092\u8FD4\u3057\u3001\u30B3\u30FC\u30C9\u30D5\u30A7\u30F3\u30B9\u3084\u8AAC\u660E\u6587\u306F\u4ED8\u3051\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002",
+    "",
+    "JSON\u30B9\u30AD\u30FC\u30DE:",
+    schemaHints[schemaName]
+  ].join("\n");
+}
+function buildRepairPrompt(schemaName, invalidOutput) {
+  return [
+    `The previous response did not match the ${schemaName} JSON schema.`,
+    "Return only corrected JSON that uses exactly the keys below.",
+    "Do not include markdown fences or commentary.",
+    "",
+    "JSON schema:",
+    schemaHints[schemaName],
+    "",
+    "Invalid response:",
+    invalidOutput
+  ].join("\n");
+}
+
+// src/storage/RunStore.ts
+import { mkdir as mkdir4, readFile as readFile4, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join3, resolve as resolve3, sep as sep2 } from "path";
+var RunStore = class {
+  root;
+  constructor(root = "runs") {
+    this.root = resolve3(root);
+  }
+  async create(runId, topic, steps, platform, style, profile) {
+    const meta = {
+      runId: this.validateRunId(runId),
+      topic,
+      platform,
+      style,
+      profile,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      steps: Object.fromEntries(steps.map((step) => [step, { status: "pending" }]))
+    };
+    await mkdir4(this.runPath(meta.runId), { recursive: true });
+    await this.writeMeta(meta);
+    return meta;
+  }
+  async readMeta(runId) {
+    const content = await readFile4(this.filePath(runId, "meta.json"), "utf8");
+    return JSON.parse(content);
+  }
+  async writeMeta(meta) {
+    const updated = { ...meta, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await mkdir4(this.runPath(updated.runId), { recursive: true });
+    await writeFile2(this.filePath(updated.runId, "meta.json"), `${JSON.stringify(updated, null, 2)}
+`, "utf8");
+  }
+  async save(runId, fileName, content) {
+    await mkdir4(this.runPath(runId), { recursive: true });
+    await writeFile2(this.filePath(runId, fileName), content.endsWith("\n") ? content : `${content}
+`, "utf8");
+  }
+  async read(runId, fileName) {
+    return readFile4(this.filePath(runId, fileName), "utf8");
+  }
+  async remove(runId, fileName) {
+    await rm(this.filePath(runId, fileName), { force: true });
+  }
+  async markDone(runId, step, fileName) {
+    const meta = await this.readMeta(runId);
+    meta.steps[step] = { status: "done", file: fileName };
+    await this.writeMeta(meta);
+    return meta;
+  }
+  runPath(runId) {
+    const safeRunId = this.validateRunId(runId);
+    const candidate = resolve3(this.root, safeRunId);
+    if (!isInside(this.root, candidate)) {
+      throw new Error("Run path escapes runs root");
+    }
+    return candidate;
+  }
+  filePath(runId, fileName) {
+    if (fileName.includes("/") || fileName.includes("\\") || fileName.includes("..")) {
+      throw new Error(`Invalid file name: ${fileName}`);
+    }
+    const candidate = resolve3(join3(this.runPath(runId), fileName));
+    if (!isInside(this.runPath(runId), candidate)) {
+      throw new Error("File path escapes run directory");
+    }
+    return candidate;
+  }
+  validateRunId(runId) {
+    if (!/^[A-Za-z0-9._-]+$/.test(runId) || runId === "." || runId === ".." || runId.includes("..")) {
+      throw new Error(`Invalid run id: ${runId}`);
+    }
+    return runId;
+  }
+};
+function isInside(root, candidate) {
+  return candidate === root || candidate.startsWith(`${root}${sep2}`);
+}
+
+// src/utils/text.ts
+function stripWrappingCodeFence(text) {
+  const trimmed = text.trim();
+  const match = trimmed.match(/^```[^\n]*\n([\s\S]*?)\n```$/);
+  if (!match) {
+    return text;
+  }
+  const inner = match[1];
+  if (inner.includes("```")) {
+    return text;
+  }
+  return inner;
+}
+function detectWrapText(markdown) {
+  const warnings = [];
+  const trimmed = markdown.trim();
+  if (!trimmed) {
+    return warnings;
+  }
+  const lines = trimmed.split("\n");
+  const firstNonEmpty = lines.find((line) => line.trim() !== "")?.trim() ?? "";
+  const preamblePatterns = [
+    /^(以下|下記)(は|に|の)/,
+    /改稿|書き直し|リライト|修正版|改訂版/,
+    /^(here is|here's|below is)\b/i,
+    /^(承知しました|了解しました|わかりました)/
+  ];
+  if (preamblePatterns.some((pattern) => pattern.test(firstNonEmpty))) {
+    warnings.push("\u5192\u982D\u306B\u524D\u7F6E\u304D\uFF08\u4F8B:\u300E\u4EE5\u4E0B\u306F\u2026\u6539\u7A3F\u7248\u3067\u3059\u300F\uFF09\u304C\u6DF7\u5165\u3057\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002");
+  }
+  const tail = lines.filter((line) => line.trim() !== "").slice(-3).join("\n");
+  const offerPatterns = [
+    "\u51FA\u3057\u76F4\u305B",
+    "\u51FA\u3057\u76F4\u3057",
+    "\u4F5C\u308A\u76F4\u305B",
+    "\u4F5C\u308A\u76F4\u3057",
+    "\u3054\u8981\u671B",
+    "\u3054\u5E0C\u671B",
+    "\u3044\u304B\u304C\u3067\u3057\u3087\u3046\u304B",
+    "\u3069\u308C\u304B\u3067",
+    "\u3044\u305A\u308C\u304B\u3067",
+    "\u5225\u306E\u7248",
+    "\u4ED6\u306E\u30D0\u30FC\u30B8\u30E7\u30F3",
+    "\u304A\u77E5\u3089\u305B\u304F\u3060\u3055\u3044",
+    "\u3054\u6307\u5B9A\u304F\u3060\u3055\u3044",
+    "\u5BFE\u5FDC\u3057\u307E\u3059"
+  ];
+  if (offerPatterns.some((pattern) => tail.includes(pattern))) {
+    warnings.push("\u672B\u5C3E\u306B\u8FFD\u52A0\u63D0\u6848\u30FB\u554F\u3044\u304B\u3051\uFF08\u4F8B:\u300E\u2026\u3067\u51FA\u3057\u76F4\u305B\u307E\u3059\u300F\uFF09\u304C\u6DF7\u5165\u3057\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002");
+  }
+  return warnings;
+}
+
+// src/workflows/qiitaSteps.ts
+function styleBlock(style) {
+  return style ? `
+\u4F5C\u6CD5:
+${style}
+` : "";
+}
+var DEFAULT_PLATFORM = "Qiita";
+var qiitaSteps = [
+  {
+    name: "brief",
+    task: "article_brief",
+    schemaName: "ArticleBrief",
+    file: "brief.json",
+    buildInput: async ({ topic, platform }) => `
+\u6B21\u306E\u30C6\u30FC\u30DE\u3067${platform}\u8A18\u4E8B\u306EArticle Brief\u3092\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+
+\u30C6\u30FC\u30DE:
+${topic}
+
+\u51FA\u529B\u306FJSON\u5F62\u5F0F\u3002
+`.trim()
+  },
+  {
+    name: "outline",
+    task: "outline",
+    schemaName: "ArticleOutline",
+    file: "outline.json",
+    buildInput: async ({ runId, store, platform }) => {
+      const brief = await store.read(runId, "brief.json");
+      return `
+\u6B21\u306EArticle Brief\u304B\u3089${platform}\u8A18\u4E8B\u306E\u69CB\u6210\u3092\u4F5C\u3063\u3066\u304F\u3060\u3055\u3044\u3002
+
+${brief}
+`.trim();
+    }
+  },
+  {
+    name: "draft",
+    task: "draft_markdown",
+    file: "draft.md",
+    buildInput: async ({ runId, store, platform, style }) => {
+      const outline = await store.read(runId, "outline.json");
+      return `
+\u6B21\u306E\u69CB\u6210\u304B\u3089${platform}\u5411\u3051Markdown\u672C\u6587\u3092\u66F8\u3044\u3066\u304F\u3060\u3055\u3044\u3002
+\u8A18\u4E8B\u672C\u6587\u306E\u307F\u3092\u51FA\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u524D\u7F6E\u304D\u30FB\u5F8C\u66F8\u304D\u30FB\u6539\u7A3F\u306E\u8AAC\u660E\u30FB\u8FFD\u52A0\u63D0\u6848\u3084\u9078\u629E\u80A2\u306E\u63D0\u793A\u306F\u542B\u3081\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002
+${styleBlock(style)}
+${outline}
+`.trim();
+    }
+  },
+  {
+    name: "review",
+    task: "technical_review",
+    schemaName: "ReviewResult",
+    file: "review.json",
+    buildInput: async ({ runId, store, platform }) => {
+      const draft = await store.read(runId, "draft.md");
+      return `
+\u6B21\u306E${platform}\u8A18\u4E8B\u3092\u6280\u8853\u30EC\u30D3\u30E5\u30FC\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+\u554F\u984C\u70B9\u3001\u6539\u5584\u6848\u3001\u4FEE\u6B63\u3059\u3079\u304D\u7B87\u6240\u3092JSON\u3067\u8FD4\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+
+${draft}
+`.trim();
+    }
+  },
+  {
+    name: "final",
+    task: "rewrite",
+    file: "final.md",
+    buildInput: async ({ runId, store, platform, style }) => {
+      const draft = await store.read(runId, "draft.md");
+      const review = await store.read(runId, "review.json");
+      return `
+\u6B21\u306E\u30EC\u30D3\u30E5\u30FC\u3092\u53CD\u6620\u3057\u3066\u3001${platform}\u8A18\u4E8B\u3092\u6539\u5584\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+\u8A18\u4E8B\u672C\u6587\u306E\u307F\u3092\u51FA\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u524D\u7F6E\u304D\u30FB\u5F8C\u66F8\u304D\u30FB\u6539\u7A3F\u306E\u8AAC\u660E\u30FB\u8FFD\u52A0\u63D0\u6848\u3084\u9078\u629E\u80A2\u306E\u63D0\u793A\u306F\u542B\u3081\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002
+${styleBlock(style)}
+\u8A18\u4E8B:
+${draft}
+
+\u30EC\u30D3\u30E5\u30FC:
+${review}
+`.trim();
+    }
+  }
+];
+function toModelRequest(step, input) {
+  return {
+    task: step.task,
+    input,
+    schemaName: step.schemaName
+  };
+}
+
+// src/workflows/createQiitaArticle.ts
+var noop = () => void 0;
+async function createQiitaArticle(router, store, topic, options = {}, onEvent = noop) {
+  const runId = options.runId ?? createRunId(topic);
+  await store.create(
+    runId,
+    topic,
+    qiitaSteps.map((step) => step.name),
+    options.platform ?? DEFAULT_PLATFORM,
+    options.style,
+    options.profile
+  );
+  return runQiitaArticle(router, store, runId, void 0, onEvent);
+}
+async function resumeQiitaArticle(router, store, runId, onEvent = noop) {
+  return runQiitaArticle(router, store, runId, void 0, onEvent);
+}
+async function reviseQiitaFinal(router, store, runId, instruction, onEvent = noop) {
+  const meta = await store.readMeta(runId);
+  const platform = meta.platform ?? DEFAULT_PLATFORM;
+  const current = await store.read(runId, "final.md");
+  await store.save(runId, "final.bak.md", current);
+  const input = [
+    `\u6B21\u306E${platform}\u8A18\u4E8B\u3092\u3001\u4EE5\u4E0B\u306E\u4FEE\u6B63\u6307\u793A\u306B\u5F93\u3063\u3066\u6539\u5584\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
+    "Markdown\u672C\u6587\u3060\u3051\u3092\u8FD4\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u8AAC\u660E\u3084\u30B3\u30FC\u30C9\u30D5\u30A7\u30F3\u30B9\u3067\u5168\u4F53\u3092\u56F2\u307E\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002",
+    ...meta.style ? ["", "\u4F5C\u6CD5:", meta.style] : [],
+    "",
+    "\u4FEE\u6B63\u6307\u793A:",
+    instruction,
+    "",
+    "\u73FE\u5728\u306E\u8A18\u4E8B:",
+    current
+  ].join("\n");
+  onEvent({ type: "step:start", index: 1, total: 1, name: "revise", task: "rewrite" });
+  const response = await router.run({ task: "rewrite", input });
+  const text = stripWrappingCodeFence(response.text);
+  await store.save(runId, "final.md", text);
+  await store.markDone(runId, "final", "final.md");
+  onEvent({
+    type: "step:done",
+    index: 1,
+    total: 1,
+    name: "revise",
+    provider: response.provider,
+    model: response.model,
+    elapsedMs: response.elapsedMs,
+    costUsd: response.usage?.costUsd,
+    truncated: response.truncated,
+    warnings: detectWrapText(text)
+  });
+  return { runId, finalText: text };
+}
+var severityRank = {
+  suggestion: 0,
+  minor: 1,
+  major: 2,
+  critical: 3
+};
+async function evaluateQiitaFinal(router, store, runId, options = {}, onEvent = noop) {
+  const minSeverity = options.minSeverity ?? "suggestion";
+  const meta = await store.readMeta(runId);
+  const platform = meta.platform ?? DEFAULT_PLATFORM;
+  const final = await store.read(runId, "final.md");
+  const input = [
+    `\u6B21\u306E${platform}\u8A18\u4E8B\u3092\u6280\u8853\u30EC\u30D3\u30E5\u30FC\u3057\u3066\u304F\u3060\u3055\u3044\u3002`,
+    "\u554F\u984C\u70B9\u30FB\u6539\u5584\u6848\u30FB\u4FEE\u6B63\u3059\u3079\u304D\u7B87\u6240\u3092JSON\u3067\u8FD4\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    ...options.criteria ? ["", "\u7279\u306B\u6B21\u306E\u8A55\u4FA1\u89B3\u70B9\u3092\u91CD\u8996\u3057\u3066\u304F\u3060\u3055\u3044:", options.criteria] : [],
+    "",
+    "\u8A18\u4E8B:",
+    final
+  ].join("\n");
+  onEvent({ type: "step:start", index: 1, total: 1, name: "evaluate", task: "final_review" });
+  const response = await router.run({ task: "final_review", input, schemaName: "ReviewResult" });
+  await store.save(runId, "final-review.json", response.text);
+  onEvent({
+    type: "step:done",
+    index: 1,
+    total: 1,
+    name: "evaluate",
+    provider: response.provider,
+    model: response.model,
+    elapsedMs: response.elapsedMs,
+    costUsd: response.usage?.costUsd,
+    truncated: response.truncated
+  });
+  const review = JSON.parse(response.text);
+  await store.save(runId, "final-review.md", buildReviewSummary(review));
+  const filtered = review.issues.filter((issue) => severityRank[issue.severity] >= severityRank[minSeverity]);
+  let instructionFile;
+  if (filtered.length > 0) {
+    await store.save(runId, "revise-instruction.md", buildRevisionInstruction(filtered));
+    instructionFile = "revise-instruction.md";
+  } else {
+    await store.remove(runId, "revise-instruction.md");
+  }
+  return {
+    runId,
+    approved: review.approved,
+    issueCount: filtered.length,
+    reviewFile: "final-review.json",
+    reviewSummaryFile: "final-review.md",
+    instructionFile
+  };
+}
+function buildReviewSummary(review) {
+  const order = ["critical", "major", "minor", "suggestion"];
+  const countLine = order.map((sev) => `${sev}: ${review.issues.filter((i) => i.severity === sev).length}`).join(" / ");
+  const verdict = review.approved === true ? "approved \u2705" : review.approved === false ? "\u8981\u4FEE\u6B63 \u26A0\uFE0F" : "n/a";
+  const lines = [
+    "# \u30EC\u30D3\u30E5\u30FC\u30B5\u30DE\u30EA",
+    "",
+    `- \u5224\u5B9A: ${verdict}`,
+    `- \u6307\u6458\u4EF6\u6570: ${countLine}\uFF08\u5408\u8A08 ${review.issues.length}\uFF09`,
+    ""
+  ];
+  if (review.summary) {
+    lines.push("## \u6982\u8981", "", review.summary, "");
+  }
+  lines.push("## \u6307\u6458\u4E00\u89A7", "");
+  if (review.issues.length === 0) {
+    lines.push("\u6307\u6458\u306F\u3042\u308A\u307E\u305B\u3093\u3002", "");
+  } else {
+    for (const sev of order) {
+      const items = review.issues.filter((issue) => issue.severity === sev);
+      if (items.length === 0) {
+        continue;
+      }
+      lines.push(`### ${sev}`);
+      for (const issue of items) {
+        const loc = issue.location ? `\uFF08${issue.location}\uFF09` : "";
+        lines.push(`- **\u554F\u984C${loc}**: ${issue.problem}`);
+        lines.push(`  - \u63A8\u5968: ${issue.recommendation}`);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function buildRevisionInstruction(issues) {
+  const lines = ["# \u4FEE\u6B63\u6307\u793A\uFF08\u8A55\u4FA1\u7D50\u679C\u304B\u3089\u81EA\u52D5\u751F\u6210 / \u8981\u78BA\u8A8D\uFF09", ""];
+  const order = ["critical", "major", "minor", "suggestion"];
+  for (const severity of order) {
+    const items = issues.filter((issue) => issue.severity === severity);
+    if (items.length === 0) {
+      continue;
+    }
+    lines.push(`## ${severity}`);
+    for (const issue of items) {
+      const loc = issue.location ? `\uFF08${issue.location}\uFF09` : "";
+      lines.push(`- \u554F\u984C${loc}: ${issue.problem}`);
+      lines.push(`  - \u63A8\u5968: ${issue.recommendation}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function rerunQiitaReview(router, store, runId, onEvent = noop) {
+  const meta = await store.readMeta(runId);
+  meta.steps.review = { status: "pending" };
+  meta.steps.final = { status: "pending" };
+  await store.writeMeta(meta);
+  return runQiitaArticle(router, store, runId, "review", onEvent);
+}
+async function runQiitaArticle(router, store, runId, startAt, onEvent = noop) {
+  const meta = await store.readMeta(runId);
+  const platform = meta.platform ?? DEFAULT_PLATFORM;
+  const style = meta.style;
+  const startIndex = startAt ? qiitaSteps.findIndex((step) => step.name === startAt) : 0;
+  const total = qiitaSteps.length;
+  for (const [index, step] of qiitaSteps.entries()) {
+    const position = index + 1;
+    if (startIndex > 0 && index < startIndex) {
+      onEvent({ type: "step:skip", index: position, total, name: step.name });
+      continue;
+    }
+    const currentMeta = await store.readMeta(runId);
+    if (currentMeta.steps[step.name]?.status === "done") {
+      onEvent({ type: "step:skip", index: position, total, name: step.name });
+      continue;
+    }
+    onEvent({ type: "step:start", index: position, total, name: step.name, task: step.task });
+    const input = await step.buildInput({ topic: meta.topic, platform, style, runId, store });
+    const response = await router.run(toModelRequest(step, input));
+    const isProse = !step.schemaName;
+    const text = isProse ? stripWrappingCodeFence(response.text) : response.text;
+    await store.save(runId, step.file, text);
+    await store.markDone(runId, step.name, step.file);
+    onEvent({
+      type: "step:done",
+      index: position,
+      total,
+      name: step.name,
+      provider: response.provider,
+      model: response.model,
+      elapsedMs: response.elapsedMs,
+      costUsd: response.usage?.costUsd,
+      truncated: response.truncated,
+      warnings: isProse ? detectWrapText(text) : void 0
+    });
+  }
+  let finalText;
+  try {
+    finalText = await store.read(runId, "final.md");
+  } catch {
+    finalText = void 0;
+  }
+  return { runId, finalText };
+}
+function createRunId(topic) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const slug = topic.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  return `${date}-${slug || "article"}`;
+}
+
+// src/index.ts
+var pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+var program = new Command();
+program.name("llm-task-router").description("Thin ModelRouter CLI for article workflows").version(pkg.version, "-v, --version", "Show the version").showHelpAfterError("(run with --help for usage)");
+program.command("init").description("Scaffold config/ and .env.example into the current directory").option("--force", "Overwrite existing files").action(async (options) => {
+  const sourceDir = fileURLToPath(new URL("..", import.meta.url));
+  const result = await initConfig(process.cwd(), sourceDir, { force: options.force });
+  for (const file of result.created) {
+    console.log(`created: ${file}`);
+  }
+  for (const file of result.skipped) {
+    console.log(`skipped (exists): ${file}`);
+  }
+  if (result.skipped.length > 0) {
+    console.log("Some files already exist; re-run with --force to overwrite them.");
+  }
+  console.log("Next: copy .env.example to .env and set your API keys, then edit config/models.yaml.");
+});
+program.command("article:create").option("--topic <topic>", "Article topic (inline text)").option("--topic-file <path>", "Path to a text file containing the topic / instructions").option("--profile <name>", "Article profile under config/profiles/ (platform + style)", "qiita").option("--platform <name>", "Override the platform label from the profile").option("--run <runId>", "Run id").option("--config <path>", "Path to models.yaml", "config/models.yaml").action(
+  async (options) => {
+    const topic = await resolveText(options.topic, options.topicFile, "topic", "--topic", "--topic-file");
+    const profile = await loadProfile(options.profile);
+    const platform = options.platform ?? profile.platform;
+    const runIdSeed = options.topicFile ? basename3(options.topicFile).replace(/\.[^.]+$/, "") : topic;
+    const runId = options.run ?? createRunId(runIdSeed);
+    const { router, store } = await createRuntime(options.config);
+    const reporter = createProgressReporter();
+    const result = await createQiitaArticle(
+      router,
+      store,
+      topic,
+      { runId, platform, style: profile.style, profile: options.profile },
+      reporter.report
+    );
+    reporter.printTotal();
+    console.log(`runId: ${result.runId}`);
+    console.log(`final: runs/${result.runId}/final.md`);
+  }
+);
+program.command("article:resume").requiredOption("--run <runId>", "Run id").option("--config <path>", "Path to models.yaml", "config/models.yaml").action(async (options) => {
+  const { router, store } = await createRuntime(options.config);
+  const reporter = createProgressReporter();
+  const result = await resumeQiitaArticle(router, store, options.run, reporter.report);
+  reporter.printTotal();
+  console.log(`runId: ${result.runId}`);
+  console.log(`final: runs/${result.runId}/final.md`);
+});
+program.command("article:review").requiredOption("--run <runId>", "Run id").option("--config <path>", "Path to models.yaml", "config/models.yaml").action(async (options) => {
+  const { router, store } = await createRuntime(options.config);
+  const reporter = createProgressReporter();
+  const result = await rerunQiitaReview(router, store, options.run, reporter.report);
+  reporter.printTotal();
+  console.log(`runId: ${result.runId}`);
+  console.log(`final: runs/${result.runId}/final.md`);
+});
+program.command("article:revise").requiredOption("--run <runId>", "Run id").option("--instruction <text>", "Revision instruction for final.md (inline text)").option("--instruction-file <path>", "Path to a text file containing the revision instruction").option("--config <path>", "Path to models.yaml", "config/models.yaml").action(async (options) => {
+  const instruction = await resolveText(
+    options.instruction,
+    options.instructionFile,
+    "instruction",
+    "--instruction",
+    "--instruction-file"
+  );
+  const { router, store } = await createRuntime(options.config);
+  const reporter = createProgressReporter();
+  const result = await reviseQiitaFinal(router, store, options.run, instruction, reporter.report);
+  reporter.printTotal();
+  console.log(`runId: ${result.runId}`);
+  console.log(`final: runs/${result.runId}/final.md (previous: runs/${result.runId}/final.bak.md)`);
+});
+program.command("article:export").requiredOption("--run <runId>", "Run id").requiredOption("--out <path>", "Destination path for the final article").option("--force", "Overwrite the destination if it already exists").action(async (options) => {
+  const store = new RunStore();
+  const dest = await exportFinalArticle(store, options.run, options.out, { force: options.force });
+  console.log(`exported: ${dest}`);
+});
+function createProgressReporter() {
+  let totalCostUsd = 0;
+  let hasCost = false;
+  const report = (event) => {
+    switch (event.type) {
+      case "step:start":
+        process.stderr.write(`[${event.index}/${event.total}] ${event.name} (${event.task}) ...
+`);
+        break;
+      case "step:skip":
+        process.stderr.write(`[${event.index}/${event.total}] ${event.name} - skip (done)
+`);
+        break;
+      case "step:done": {
+        if (event.costUsd !== void 0) {
+          totalCostUsd += event.costUsd;
+          hasCost = true;
+        }
+        const cost = event.costUsd !== void 0 ? `, ~$${event.costUsd.toFixed(4)}` : "";
+        process.stderr.write(
+          `[${event.index}/${event.total}] ${event.name} - done via ${event.provider}/${event.model} (${event.elapsedMs}ms${cost})
+`
+        );
+        if (event.truncated) {
+          process.stderr.write(
+            `  \u26A0 ${event.name}: \u51FA\u529B\u304C max_tokens \u3067\u6253\u3061\u5207\u3089\u308C\u305F\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002models.yaml \u306E max_tokens \u3092\u5897\u3084\u3057\u3066\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+`
+          );
+        }
+        for (const warning of event.warnings ?? []) {
+          process.stderr.write(`  \u26A0 ${event.name}: ${warning}
+`);
+        }
+        break;
+      }
+    }
+  };
+  const printTotal = () => {
+    if (hasCost) {
+      process.stderr.write(`total: ~$${totalCostUsd.toFixed(4)} (estimate)
+`);
+    }
+  };
+  return { report, printTotal };
+}
+program.command("article:evaluate").requiredOption("--run <runId>", "Run id").option("--min-severity <level>", "Minimum severity to include (critical|major|minor|suggestion)", "suggestion").option("--criteria <text>", "Evaluation focus / points (inline text)").option("--criteria-file <path>", "Path to a text file with evaluation focus").option("--config <path>", "Path to models.yaml", "config/models.yaml").action(
+  async (options) => {
+    const minSeverity = parseSeverity(options.minSeverity);
+    const { router, store } = await createRuntime(options.config);
+    const criteria = await resolveEvaluationCriteria(store, options);
+    const reporter = createProgressReporter();
+    const result = await evaluateQiitaFinal(router, store, options.run, { minSeverity, criteria }, reporter.report);
+    reporter.printTotal();
+    console.log(`runId: ${result.runId}`);
+    console.log(
+      `review: runs/${result.runId}/${result.reviewFile} (approved: ${result.approved ?? "n/a"}, issues>=${minSeverity}: ${result.issueCount})`
+    );
+    console.log(`summary: runs/${result.runId}/${result.reviewSummaryFile}`);
+    if (result.instructionFile) {
+      console.log(`instruction: runs/${result.runId}/${result.instructionFile}`);
+    } else {
+      console.log(`instruction: (none \u2014 no issues at or above ${minSeverity})`);
+    }
+  }
+);
+async function resolveEvaluationCriteria(store, options) {
+  if (options.criteria !== void 0 || options.criteriaFile !== void 0) {
+    return resolveText(options.criteria, options.criteriaFile, "criteria", "--criteria", "--criteria-file");
+  }
+  const meta = await store.readMeta(options.run);
+  if (meta.profile) {
+    const profile = await loadProfile(meta.profile);
+    if (profile.criteriaFile) {
+      assertSafeInputPath(profile.criteriaFile);
+      const content = (await readFile5(profile.criteriaFile, "utf8")).trim();
+      if (content) {
+        process.stderr.write(`criteria: ${meta.profile} \u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u306E ${profile.criteriaFile} \u3092\u4F7F\u7528
+`);
+        return content;
+      }
+    }
+  }
+  return void 0;
+}
+function parseSeverity(value) {
+  const allowed = ["critical", "major", "minor", "suggestion"];
+  if (!allowed.includes(value)) {
+    throw new Error(`Invalid --min-severity: ${value} (use critical|major|minor|suggestion)`);
+  }
+  return value;
+}
+async function createRuntime(configPath) {
+  const config = await loadRouterConfig(configPath);
+  const providers = createProviders(config);
+  const logger = new RunLogger();
+  const router = new ModelRouter(providers, config, logger);
+  const store = new RunStore();
+  return { router, store };
+}
+if (process.argv.slice(2).length === 0) {
+  program.outputHelp();
+} else {
+  program.parseAsync().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exitCode = 1;
+  });
+}