alanbox 0.1.1

package/0commondflowv1/src/core/workers.js

@@ -0,0 +1,172 @@
+/**
+ * worker 规划辅助函数。
+ * 解析 worker 规格、匹配配置 worker，并生成依赖层级。
+ */
+
+function parseWorkerSpecs(specs, parallel, config) {
+  const usedIds = new Set();
+  const stages = specs.map((spec) => parseWorkerStageSpec(spec));
+  let taskIndex = 0;
+
+  const tasksByStage = stages.map((stageSpecs) => stageSpecs.map((stageSpec) => {
+    const task = parseTaskSpec(stageSpec, taskIndex, config);
+    taskIndex += 1;
+    const idBase = task.role.replace(/\s+/g, '-');
+    let id = idBase;
+    let suffix = 2;
+    while (usedIds.has(id)) {
+      id = `${idBase}-${suffix++}`;
+    }
+    usedIds.add(id);
+    return { ...task, id };
+  }));
+
+  if (parallel) {
+    return tasksByStage.flat();
+  }
+
+  return tasksByStage.flatMap((stage, stageIndex) => {
+    if (stageIndex === 0) return stage;
+    const dependsOn = tasksByStage[stageIndex - 1].map((task) => task.id);
+    return stage.map((task) => ({ ...task, dependsOn }));
+  });
+}
+
+function parseWorkerStageSpec(spec) {
+  const text = String(spec || '').trim();
+  if (!text.startsWith('[')) return [text];
+  if (!text.endsWith(']')) {
+    throw new Error(`invalid grouped --worker "${spec}". Expected "[<worker>:<role>:<prompt>,<worker>:<role>:<prompt>]".`);
+  }
+
+  const inner = text.slice(1, -1).trim();
+  if (!inner) {
+    throw new Error('empty grouped --worker. Expected at least one worker spec inside [].');
+  }
+
+  const parts = splitGroupedWorkerSpecs(inner);
+  if (parts.length === 0) {
+    throw new Error('empty grouped --worker. Expected at least one worker spec inside [].');
+  }
+  return parts;
+}
+
+function splitGroupedWorkerSpecs(text) {
+  const parts = [];
+  let current = '';
+  let escaping = false;
+
+  for (const char of text) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === '\\') {
+      escaping = true;
+      continue;
+    }
+    if (char === ',') {
+      const part = current.trim();
+      if (part) parts.push(part);
+      current = '';
+      continue;
+    }
+    current += char;
+  }
+
+  if (escaping) current += '\\';
+  const tail = current.trim();
+  if (tail) parts.push(tail);
+  return parts;
+}
+
+function parseTaskSpec(spec, index, config) {
+  const firstColon = spec.indexOf(':');
+  const secondColon = firstColon >= 0 ? spec.indexOf(':', firstColon + 1) : -1;
+  if (firstColon < 0 || secondColon < 0) {
+    throw new Error(`invalid --worker "${spec}". Expected "<platform-or-worker>:<role>:<prompt>".`);
+  }
+
+  const platformOrWorker = spec.slice(0, firstColon).trim();
+  const { provider, worker } = resolveWorkerFromPlatform(platformOrWorker, index, config);
+  const isDynamicWorker = worker.startsWith('worker-');
+  if (!isDynamicWorker && !config.workers?.[worker]) {
+    throw new Error(`unknown worker "${platformOrWorker}". Allowed: codex, worker-<n>, or configured workers: ${Object.keys(config.workers || {}).join(', ')}`);
+  }
+
+  const role = spec.slice(firstColon + 1, secondColon).trim() || `worker-${index + 1}`;
+  const prompt = spec.slice(secondColon + 1).trim();
+  if (!prompt) {
+    throw new Error(`missing prompt in --task "${spec}"`);
+  }
+
+  return { platform: provider, provider, worker, role, prompt };
+}
+
+function resolveWorkerFromPlatform(value, index, config) {
+  const text = String(value || '').trim().toLowerCase();
+  if (text === 'codex') {
+    return {
+      provider: 'codex',
+      worker: index === 0 && config.primaryWorker ? config.primaryWorker : `worker-${index + 1}`,
+    };
+  }
+  if (text === 'claude') {
+    return {
+      provider: 'claude',
+      worker: `worker-${index + 1}`,
+    };
+  }
+  const worker = normalizeWorkerName(text);
+  const workerProvider = config.workers?.[worker]?.provider || config.defaultProvider || 'codex';
+  return { provider: workerProvider, worker };
+}
+
+function normalizeWorkerName(value) {
+  const text = String(value || '').trim();
+  if (/^codex-\d+$/.test(text)) return text.replace(/^codex-/, 'worker-');
+  if (/^\d+$/.test(text)) return `worker-${text}`;
+  return text;
+}
+
+function buildDependencyLevels(tasks) {
+  const levels = [];
+  const placed = new Set();
+
+  while (placed.size < tasks.length) {
+    const level = [];
+    for (const task of tasks) {
+      if (placed.has(task.id)) continue;
+      const depsReady = !task.dependsOn || task.dependsOn.every((dep) => placed.has(dep));
+      if (depsReady) {
+        level.push(task);
+      }
+    }
+
+    if (level.length === 0) {
+      for (const task of tasks) {
+        if (!placed.has(task.id)) level.push(task);
+      }
+    }
+
+    for (const task of level) {
+      placed.add(task.id);
+    }
+    levels.push(level);
+  }
+
+  return levels;
+}
+
+module.exports = {
+  parseWorkerSpecs,
+  parseWorkerStageSpec,
+  splitGroupedWorkerSpecs,
+  parseTaskSpec,
+  resolveWorkerFromPlatform,
+  normalizeWorkerName,
+  buildDependencyLevels,
+};
+
+

package/0commondflowv1/src/core/workflow-planner.js

@@ -0,0 +1,366 @@
+/**
+ * 最小 GOAP workflow planner。
+ * 只实现本地 CLI 需要的 Goal / WorldState / Action 抽象，不引入 daemon、Redis 或 Ruflo 大架构。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { renderRoleTemplate } = require('./prompt-templates');
+const { sanitizePathPart } = require('./storage');
+
+const DEFAULT_EXCLUDES = new Set(['.git', 'node_modules', 'dist', 'build', '.next', 'coverage', '.cache', '.sub-codex']);
+const MAX_AUTO_DIR_AGENTS = 12;
+
+function planWorkflow({ goal, cwd, namespace, agentSpecs = [], planHint = '', config, previousFailures = [] }) {
+  const worldState = buildInitialWorldState({ goal, cwd, namespace, agentSpecs, planHint, previousFailures });
+  const agents = normalizeAgentSpecs(agentSpecs, config);
+  const reviewTargets = chooseReviewTargets({ cwd, planHint, agents });
+  const reviewAgents = buildReviewActions({ goal, cwd, planHint, agents, reviewTargets, previousFailures });
+  const synthAction = buildSyntheticAction({
+    id: 'synthesize',
+    type: 'synthesize',
+    role: 'synthesizer',
+    provider: 'codex',
+    prompt: '汇总所有 reviewer 的结果，去重问题，给出最终判断和建议执行顺序。',
+    dependsOn: reviewAgents.map((action) => action.id),
+    goal,
+    cwd,
+    planHint,
+    expectedState: 'reviewFindings 已汇总，形成可读报告。',
+  });
+  const verifyAction = buildSyntheticAction({
+    id: 'verify',
+    type: 'verify',
+    role: 'verifier',
+    provider: 'codex',
+    prompt: '验证目标是否已经达成；如果没有达成，请在 HANDOFF_JSON.status 中返回 failed 或 blocked，并说明原因。',
+    dependsOn: [synthAction.id],
+    goal,
+    cwd,
+    planHint,
+    expectedState: 'goalVerified 为 true，或者给出需要重规划的失败原因。',
+  });
+  const actions = [...reviewAgents, synthAction, verifyAction];
+  const workflow = {
+    schemaVersion: 1,
+    mode: 'auto-swarm',
+    namespace,
+    goal,
+    cwd,
+    planHint,
+    worldState,
+    phases: buildPhases(actions),
+    actions,
+    expectedWorldStateChanges: [
+      'goalCaptured: false -> true',
+      'workflowRecommended: false -> true',
+      'reviewFindings: [] -> reviewer handoff summaries',
+      'goalVerified: false -> verifier judgement',
+    ],
+    risks: buildRisks({ reviewTargets, previousFailures }),
+  };
+  workflow.planHash = hashPlan(workflow);
+  return workflow;
+}
+
+function buildInitialWorldState({ goal, cwd, namespace, agentSpecs, planHint, previousFailures }) {
+  return {
+    goalCaptured: Boolean(goal),
+    workflowRecommended: false,
+    approved: false,
+    executedActions: [],
+    failedActions: previousFailures.map((item) => item.id || item.actionId || '').filter(Boolean),
+    goalVerified: false,
+    cwd,
+    namespace,
+    agentCount: agentSpecs.length,
+    hasPlanHint: Boolean(planHint),
+  };
+}
+
+function normalizeAgentSpecs(agentSpecs, config) {
+  const specs = Array.isArray(agentSpecs) ? agentSpecs.filter(Boolean) : [];
+  if (specs.length === 0) {
+    return [{ provider: 'codex', worker: 'worker-1', role: 'reviewer', prompt: '复核当前项目代码。' }];
+  }
+  return specs.map((spec, index) => parseAutoAgentSpec(spec, index, config));
+}
+
+function parseAutoAgentSpec(spec, index, config) {
+  const text = String(spec || '').trim();
+  const firstColon = text.indexOf(':');
+  if (firstColon < 0) {
+    return { provider: 'codex', worker: `worker-${index + 1}`, role: `agent-${index + 1}`, prompt: text };
+  }
+
+  const first = text.slice(0, firstColon).trim();
+  const rest = text.slice(firstColon + 1);
+  const secondColon = rest.indexOf(':');
+  const knownProvider = ['codex', 'claude'].includes(first.toLowerCase());
+  const knownWorker = isWorkerName(first) || Boolean(config.workers?.[first]);
+
+  if ((knownProvider || knownWorker) && secondColon >= 0) {
+    const role = rest.slice(0, secondColon).trim() || `agent-${index + 1}`;
+    const prompt = rest.slice(secondColon + 1).trim();
+    const provider = knownProvider ? first.toLowerCase() : (config.workers?.[first]?.provider || config.defaultProvider || 'codex');
+    const worker = knownProvider ? `worker-${index + 1}` : first;
+    return { provider, worker, role, prompt };
+  }
+
+  return {
+    provider: 'codex',
+    worker: `worker-${index + 1}`,
+    role: first || `agent-${index + 1}`,
+    prompt: rest.trim(),
+  };
+}
+
+function isWorkerName(value) {
+  return /^worker-[A-Za-z0-9_.-]+$/i.test(value) || /^codex-\d+$/i.test(value) || /^\d+$/.test(value);
+}
+
+function chooseReviewTargets({ cwd, planHint, agents }) {
+  if (!shouldFanOutBySubdir(planHint)) {
+    return [];
+  }
+
+  let entries = [];
+  try {
+    entries = fs.readdirSync(cwd, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const dirs = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .filter((name) => !DEFAULT_EXCLUDES.has(name))
+    .slice(0, MAX_AUTO_DIR_AGENTS)
+    .map((name) => path.join(cwd, name));
+
+  if (dirs.length === 0 && agents.length > 0) return [];
+  return dirs;
+}
+
+function shouldFanOutBySubdir(planHint) {
+  return /子文件夹|子目录|每个.*(目录|文件夹)|parallel|并行/i.test(String(planHint || ''));
+}
+
+function buildReviewActions({ goal, cwd, planHint, agents, reviewTargets, previousFailures }) {
+  const baseAgents = agents.length ? agents : [{ provider: 'codex', worker: 'worker-1', role: 'reviewer', prompt: goal }];
+  const targets = reviewTargets.length ? reviewTargets : baseAgents.map((agent) => agent.target || '');
+
+  if (reviewTargets.length > 0) {
+    const base = baseAgents[0] || { provider: 'codex', role: 'reviewer', prompt: goal };
+    return reviewTargets.map((target, index) => buildReviewAction({
+      goal,
+      cwd,
+      planHint,
+      previousFailures,
+      agent: {
+        ...base,
+        worker: `worker-${index + 1}`,
+        role: base.role || 'reviewer',
+        prompt: `${base.prompt || goal}\n重点路径：${target}`,
+      },
+      index,
+      target,
+    }));
+  }
+
+  return baseAgents.map((agent, index) => buildReviewAction({
+    goal,
+    cwd,
+    planHint,
+    previousFailures,
+    agent,
+    index,
+    target: '',
+  }));
+}
+
+function buildReviewAction({ goal, cwd, planHint, previousFailures, agent, index, target }) {
+  const idBase = `${agent.role || 'review'}-${target ? path.basename(target) : index + 1}`;
+  const id = uniqueActionId('review', idBase, index);
+  const retryContext = previousFailures.length
+    ? `\n上次失败信息：${previousFailures.map((item) => item.error || item.summary || item.id).join('；')}`
+    : '';
+  const task = [agent.prompt || goal, retryContext].filter(Boolean).join('\n');
+  const expectedState = target
+    ? `完成 ${target} 的复核，输出问题、证据和 HANDOFF_JSON。`
+    : '完成指定范围复核，输出问题、证据和 HANDOFF_JSON。';
+  const rendered = renderRoleTemplate({
+    role: agent.role || 'reviewer',
+    goal,
+    task,
+    cwd,
+    constraints: planHint,
+    expectedState,
+  });
+
+  return {
+    id,
+    type: 'review',
+    provider: agent.provider || 'codex',
+    worker: agent.worker || `worker-${index + 1}`,
+    role: agent.role || 'reviewer',
+    prompt: rendered.text,
+    dependsOn: [],
+    target,
+    expectedEffects: ['reviewFindings += handoff.findings', expectedState],
+    template: summarizeTemplate(rendered.resolution),
+  };
+}
+
+function buildSyntheticAction({ id, type, role, provider, prompt, dependsOn, goal, cwd, planHint, expectedState }) {
+  const rendered = renderRoleTemplate({
+    role,
+    goal,
+    task: prompt,
+    cwd,
+    constraints: planHint,
+    expectedState,
+  });
+  return {
+    id,
+    type,
+    provider,
+    worker: `worker-${role}`,
+    role,
+    prompt: rendered.text,
+    dependsOn,
+    target: '',
+    expectedEffects: [expectedState],
+    template: summarizeTemplate(rendered.resolution),
+  };
+}
+
+function summarizeTemplate(resolution) {
+  return {
+    name: resolution.template,
+    path: resolution.path,
+    fallback: resolution.fallback,
+    inline: resolution.inline,
+  };
+}
+
+function uniqueActionId(prefix, value, index) {
+  return `${prefix}-${sanitizePathPart(value || index + 1).toLowerCase()}`;
+}
+
+function buildPhases(actions) {
+  const reviewIds = actions.filter((action) => action.type === 'review').map((action) => action.id);
+  const synthesizeIds = actions.filter((action) => action.type === 'synthesize').map((action) => action.id);
+  const verifyIds = actions.filter((action) => action.type === 'verify').map((action) => action.id);
+  return [
+    { id: 'review', title: '并行复核', actionIds: reviewIds, parallel: true },
+    { id: 'synthesize', title: '汇总结果', actionIds: synthesizeIds, parallel: false },
+    { id: 'verify', title: '验证目标', actionIds: verifyIds, parallel: false },
+  ].filter((phase) => phase.actionIds.length > 0);
+}
+
+function buildRisks({ reviewTargets, previousFailures }) {
+  const risks = [
+    'auto workflow 会调用真实 provider；执行前请先使用 --dry-run 查看计划。',
+    '如果 workflow 新增 action、扩大目录或改变 provider，应重新确认后再执行。',
+  ];
+  if (reviewTargets.length >= MAX_AUTO_DIR_AGENTS) {
+    risks.push(`子目录 fan-out 已限制为前 ${MAX_AUTO_DIR_AGENTS} 个目录，避免一次启动过多 worker。`);
+  }
+  if (previousFailures.length) {
+    risks.push('这是基于失败信息生成的重规划，需重点检查失败 action 的范围是否扩大。');
+  }
+  return risks;
+}
+
+function workflowToTasks(workflow, namespace) {
+  return workflow.actions.map((action, index) => ({
+    id: action.id,
+    worker: action.worker || `worker-${index + 1}`,
+    provider: action.provider || 'codex',
+    platform: action.provider || 'codex',
+    role: action.role,
+    prompt: action.prompt,
+    dependsOn: action.dependsOn || [],
+    namespace,
+    workflowAction: {
+      type: action.type,
+      target: action.target,
+      expectedEffects: action.expectedEffects,
+      template: action.template,
+    },
+  }));
+}
+
+function replanWorkflow({ workflow, failures, cwd, namespace, config, planHint }) {
+  const failedIds = new Set(failures.map((item) => item.id).filter(Boolean));
+  const retryableActions = workflow.actions.filter((action) => failedIds.has(action.id) && action.type !== 'verify');
+  if (retryableActions.length === 0) {
+    return planWorkflow({
+      goal: workflow.goal,
+      cwd,
+      namespace,
+      agentSpecs: [],
+      planHint,
+      config,
+      previousFailures: failures,
+    });
+  }
+
+  const retryActions = retryableActions.map((action, index) => ({
+    ...action,
+    id: `${action.id}-retry-${index + 1}`,
+    dependsOn: [],
+    prompt: `${action.prompt}\n\n这是失败后的重试。请先阅读上次失败信息，并只在原范围内修复/复核：${JSON.stringify(failures)}`,
+    expectedEffects: [...(action.expectedEffects || []), 'retryFailureResolved: false -> true'],
+  }));
+  const synthAction = buildSyntheticAction({
+    id: 'synthesize-retry',
+    type: 'synthesize',
+    role: 'synthesizer',
+    provider: 'codex',
+    prompt: '汇总重试 action 的结果，并说明是否已经解决失败原因。',
+    dependsOn: retryActions.map((action) => action.id),
+    goal: workflow.goal,
+    cwd,
+    planHint,
+    expectedState: '重试结果已汇总。',
+  });
+  const verifyAction = buildSyntheticAction({
+    id: 'verify-retry',
+    type: 'verify',
+    role: 'verifier',
+    provider: 'codex',
+    prompt: '验证重试后目标是否达成；未达成则返回 failed 或 blocked。',
+    dependsOn: [synthAction.id],
+    goal: workflow.goal,
+    cwd,
+    planHint,
+    expectedState: '重试后的 goalVerified 为 true。',
+  });
+  const actions = [...retryActions, synthAction, verifyAction];
+  const next = {
+    ...workflow,
+    replannedFrom: workflow.planHash,
+    actions,
+    phases: buildPhases(actions),
+    risks: buildRisks({ reviewTargets: [], previousFailures: failures }),
+  };
+  next.planHash = hashPlan(next);
+  return next;
+}
+
+function hashPlan(workflow) {
+  const copy = JSON.parse(JSON.stringify(workflow));
+  delete copy.planHash;
+  return crypto.createHash('sha256').update(JSON.stringify(copy)).digest('hex');
+}
+
+module.exports = {
+  planWorkflow,
+  workflowToTasks,
+  replanWorkflow,
+  parseAutoAgentSpec,
+  hashPlan,
+};

package/0commondflowv1/src/core/workflow-storage.js

@@ -0,0 +1,123 @@
+/**
+ * Auto workflow 的本地 AgentDB-lite 存储。
+ * 只负责 workflow run 级状态；旧 swarm 的 results/memory 路径仍由 storage.js 维护。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { resolveRunDir, sanitizePathPart } = require('./storage');
+
+function createRunId() {
+  const stamp = new Date().toISOString().replace(/[-:TZ.]/g, '').slice(0, 14);
+  const suffix = Math.random().toString(36).slice(2, 8);
+  return `run-${stamp}-${suffix}`;
+}
+
+function resolveWorkflowRunDir(namespace, runId) {
+  return path.join(resolveRunDir(namespace), 'runs', sanitizePathPart(runId));
+}
+
+function createWorkflowRun({ namespace, runId = createRunId(), goal, cwd }) {
+  const runDir = resolveWorkflowRunDir(namespace, runId);
+  return {
+    namespace,
+    runId,
+    goal,
+    cwd,
+    runDir,
+    resultDir: path.join(runDir, 'results'),
+    memoryDir: path.join(runDir, 'memory'),
+    statePath: path.join(runDir, 'state.json'),
+    planPath: path.join(runDir, 'plan.json'),
+    runPath: path.join(runDir, 'run.json'),
+    stepsPath: path.join(runDir, 'steps.jsonl'),
+  };
+}
+
+function loadWorkflowRun(namespace, runId) {
+  const runDir = resolveWorkflowRunDir(namespace, runId);
+  const runPath = path.join(runDir, 'run.json');
+  if (!fs.existsSync(runPath)) {
+    throw new Error(`workflow run not found: ${runId}`);
+  }
+  const run = readJson(runPath);
+  return createWorkflowRun({
+    namespace: run.namespace || namespace,
+    runId: run.runId || runId,
+    goal: run.goal || '',
+    cwd: run.cwd || process.cwd(),
+  });
+}
+
+function saveRunMetadata(run, data) {
+  writeJson(run.runPath, {
+    schemaVersion: 1,
+    namespace: run.namespace,
+    runId: run.runId,
+    goal: run.goal,
+    cwd: run.cwd,
+    createdAt: data.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    status: data.status,
+    planHash: data.planHash,
+  });
+}
+
+function savePlan(run, workflow) {
+  writeJson(run.planPath, workflow);
+}
+
+function saveState(run, state) {
+  writeJson(run.statePath, {
+    schemaVersion: 1,
+    namespace: run.namespace,
+    runId: run.runId,
+    updatedAt: new Date().toISOString(),
+    ...state,
+  });
+}
+
+function appendStep(run, event) {
+  fs.mkdirSync(path.dirname(run.stepsPath), { recursive: true });
+  fs.appendFileSync(run.stepsPath, `${JSON.stringify({
+    at: new Date().toISOString(),
+    ...event,
+  })}\n`, 'utf8');
+}
+
+function readPlan(run) {
+  return readJson(run.planPath);
+}
+
+function readState(run) {
+  return readJson(run.statePath);
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp`;
+  fs.writeFileSync(tempPath, JSON.stringify(value, null, 2), 'utf8');
+  fs.renameSync(tempPath, filePath);
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`failed to read JSON ${filePath}: ${error.message}`);
+  }
+}
+
+module.exports = {
+  createRunId,
+  resolveWorkflowRunDir,
+  createWorkflowRun,
+  loadWorkflowRun,
+  saveRunMetadata,
+  savePlan,
+  saveState,
+  appendStep,
+  readPlan,
+  readState,
+  writeJson,
+};

package/0commondflowv1/src/prompt/AGENTS.md

@@ -0,0 +1,16 @@
+## prompt
+
+`0commondflowv1/src/prompt` 存放随源码维护的可复用提示词模板
+
+### Important files
+
+- `reviewer.md` — 代码审查提示词模板，指导 reviewer 输出阻塞问题、非阻塞建议、检查范围和结论。
+- `default.md` — auto workflow role 模板 fallback。
+- `synthesizer.md` — 汇总多个 reviewer handoff 的模板。
+- `verifier.md` — 验证目标是否达成、失败原因和是否需要重规划的模板。
+
+### Implementation notes
+
+- 新增提示词时优先使用小写短文件名，例如 `review.md`。
+- 提示词应说明角色、目标、工作方式、输出格式和约束；不要写入一次性排查结论。
+- 如果提示词被 CLI 参数、README、skills 或默认配置引用，修改时同步检查对应说明。

package/0commondflowv1/src/prompt/default.md

@@ -0,0 +1,30 @@
+# Default Agent Prompt
+
+你是 multirunagent auto workflow 中的 {{role}} agent。
+
+## 目标
+
+{{goal}}
+
+## 当前任务
+
+{{task}}
+
+## 工作目录
+
+{{cwd}}
+
+## 补充约束
+
+{{constraints}}
+
+## 预期状态变化
+
+{{expectedState}}
+
+## 输出要求
+
+- 用中文输出。
+- 只处理当前任务，不扩展范围。
+- 给出可复核的证据、文件路径或命令结果。
+- 最后输出 `HANDOFF_JSON` fenced JSON，字段包含 status、summary、files、findings、nextSteps、artifacts，可选 verification。