@fitlab-ai/agent-infra 0.11.11 → 0.11.13

package/lib/task/runtime-paths.ts

@@ -0,0 +1,12 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolveTaskRef } from './resolve-ref.ts';
+
+export function resolveTaskRuntimeRoot(
+  taskRef: string,
+  options: Readonly<{ repoRoot?: string }> = {}
+): string {
+  const resolved = resolveTaskRef(taskRef, options);
+  if (!resolved.ok) throw new Error(`${resolved.code}: ${resolved.message}`);
+  return path.join(fs.realpathSync.native(resolved.taskDir), '.runtime');
+}

package/lib/task/short-id.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { parseTypedTaskFrontmatter } from './frontmatter.ts';
 
 const REGISTRY_NAME = '.short-ids.json';
 const LOCK_NAME = '.short-ids.json.lock';
@@ -159,43 +160,35 @@ function resolveShortIdReadOnly(
   const taskId = ids[key];
   if (!taskId) {
     const message = Object.keys(ids).length === 0
-      ? `short id '${key}' not found; active task registry is empty.`
-      : `short id '${key}' not found in active task registry (it may have been cleaned up after archival; check 'task-short-id.js list').`;
+      ? `short id '${key}' not found; task short-id registry is empty.`
+      : `short id '${key}' not found in task short-id registry.`;
     return shortIdFailure('SHORT_ID_NOT_FOUND', message);
   }
-  const taskMdPath = path.join(
-    repoRoot,
-    '.agents',
-    'workspace',
-    'active',
-    taskId,
-    'task.md'
-  );
-  if (!fs.existsSync(taskMdPath)) {
-    const remainingActiveEntries = Object.values(ids).filter((candidateTaskId) =>
-      fs.existsSync(
-        path.join(
-          repoRoot,
-          '.agents',
-          'workspace',
-          'active',
-          candidateTaskId,
-          'task.md'
-        )
-      )
-    );
-    const message = remainingActiveEntries.length === 0
-      ? `short id '${key}' not found; active task registry is empty.`
-      : `short id '${key}' not found in active task registry (it may have been cleaned up after archival; check 'task-short-id.js list').`;
+  const activeTask = path.join(repoRoot, '.agents', 'workspace', 'active', taskId, 'task.md');
+  const completedTask = path.join(repoRoot, '.agents', 'workspace', 'completed', taskId, 'task.md');
+  let isValidCompletedTask = false;
+  try {
+    const task = parseTypedTaskFrontmatter(fs.readFileSync(completedTask, 'utf8'));
+    isValidCompletedTask = task.id === taskId && task.status === 'completed';
+  } catch { /* a mapping is valid only while its task content is present */ }
+  if (!fs.existsSync(activeTask) && !isValidCompletedTask) {
     return shortIdFailure(
       'SHORT_ID_STALE',
-      message,
+      `short id '${key}' points to no active or completed task content.`,
       taskId
     );
   }
   return { ok: true, taskId };
 }
 
+function hasRetainedCompletedTask(activeDir: string, taskId: string): boolean {
+  try {
+    const taskPath = path.join(path.dirname(activeDir), 'completed', taskId, 'task.md');
+    const task = parseTypedTaskFrontmatter(fs.readFileSync(taskPath, 'utf8'));
+    return task.id === taskId && task.status === 'completed';
+  } catch { return false; }
+}
+
 type RegistrySchema = {
   version: number;
   ids: Record<string, string>;
@@ -339,7 +332,8 @@ function mutateShortIdRegistryAt(
     const original = JSON.stringify(registry.ids);
     if (pruneOrphans) {
       for (const [key, candidate] of Object.entries(registry.ids)) {
-        if (candidate !== taskId && !fs.existsSync(path.join(activeDir, candidate, 'task.md'))) delete registry.ids[key];
+        if (candidate !== taskId && !fs.existsSync(path.join(activeDir, candidate, 'task.md'))
+          && !hasRetainedCompletedTask(activeDir, candidate)) delete registry.ids[key];
       }
     }
     const existing = Object.entries(registry.ids).find(([, candidate]) => candidate === taskId);
@@ -406,28 +400,27 @@ function executeShortIdCommand(request: ShortIdCommandRequest): ShortIdCommandRe
       if (normalized.kind !== 'shortId') {
         throw Object.assign(new Error(`invalid short id format '${request.argument}'`), { code: 'SHORT_ID_FORMAT_INVALID' });
       }
-      return withRegistryLock(request.activeDir, () => {
-        const registry = readRegistryStrict(registryPath, request.shortIdLength);
-        let changed = false;
-        for (const [key, taskId] of Object.entries(registry.ids)) {
-          if (!fs.existsSync(path.join(request.activeDir, taskId, 'task.md'))) { delete registry.ids[key]; changed = true; }
-        }
-        if (changed) writeRegistry(registryPath, registry);
-        const taskId = registry.ids[normalized.value];
-        if (!taskId) throw Object.assign(new Error(`short id '${normalized.value}' not found in active task registry`), { code: 'SHORT_ID_NOT_FOUND' });
-        return { status: changed ? 'applied' : 'no-op', changed, output: taskId, error: null };
-      });
+      const registry = readRegistryStrict(registryPath, request.shortIdLength);
+      const taskId = registry.ids[normalized.value];
+      if (!taskId) throw Object.assign(new Error(`short id '${normalized.value}' not found in task short-id registry`), { code: 'SHORT_ID_NOT_FOUND' });
+      if (!fs.existsSync(path.join(request.activeDir, taskId, 'task.md'))
+        && !hasRetainedCompletedTask(request.activeDir, taskId)) {
+        throw Object.assign(new Error(`short id '${normalized.value}' points to a task without active or completed task content`), { code: 'SHORT_ID_STALE' });
+      }
+      return { status: 'no-op', changed: false, output: taskId, error: null };
     }
     const registry = readRegistryStrict(registryPath, request.shortIdLength);
     if (request.verify) {
       const active = fs.existsSync(request.activeDir)
         ? fs.readdirSync(request.activeDir).filter((entry) => /^TASK-\d{8}-\d{6}$/.test(entry) && fs.existsSync(path.join(request.activeDir, entry, 'task.md')))
         : [];
+      const retained = Object.values(registry.ids).filter((taskId) => hasRetainedCompletedTask(request.activeDir, taskId));
+      const validTasks = new Set([...active, ...retained]);
       const registered = new Map<string, string[]>();
       for (const [key, taskId] of Object.entries(registry.ids)) registered.set(taskId, [...(registered.get(taskId) ?? []), key]);
       const diff = {
         missing_in_registry: active.filter((taskId) => !registered.has(taskId)).map((taskId) => ({ taskId })),
-        orphans_in_registry: Object.entries(registry.ids).filter(([, taskId]) => !active.includes(taskId)).map(([key, taskId]) => ({ key, taskId })),
+        orphans_in_registry: Object.entries(registry.ids).filter(([, taskId]) => !validTasks.has(taskId)).map(([key, taskId]) => ({ key, taskId })),
         duplicate_registry_keys: [...registered.entries()].filter(([, keys]) => keys.length > 1).map(([taskId, keys]) => ({ taskId, keys }))
       };
       const clean = Object.values(diff).every((items) => items.length === 0);

package/lib/task/verification-engine.ts

@@ -43,6 +43,7 @@ import { manualValidationFinalSummaryProjectionMatches } from "./manual-validati
 import { readManualValidationCompletion } from "./manual-validation-completion.ts";
 import { sha256File } from "./artifact-receipts.ts";
 import { inspectArtifactDirectory } from "./artifact-lifecycle.ts";
+import { getAgentClientAdapter } from "../agent-clients/registry.ts";
 import { parseArtifactName } from "./artifact-name.ts";
 import { summaryCommentState } from "../platform/pr-summary.ts";
 import { taskIssueIdentity } from "../platform/task-identities.ts";
@@ -147,7 +148,7 @@ async function runCheck(type: any, context: any, shared: any): Promise<any> {
 }
 
 function checkOrchestrationState({ taskDir }: any): any {
-  const file = path.join(taskDir, 'orchestration.json');
+  const file = path.join(taskDir, '.runtime', 'orchestration.json');
   const stat = safeStat(file);
   if (!stat?.isFile()) return failResult('orchestration-state', 'orchestration.json is missing');
   let run: OrchestrationRun | null;
@@ -160,16 +161,14 @@ function checkOrchestrationState({ taskDir }: any): any {
   if (!run || !['paused', 'completed'].includes(run.status)) {
     return failResult('orchestration-state', `Expected paused or completed run, received '${run?.status ?? 'missing'}'`);
   }
+  const adapterEvidenceError = validateAdapterReceiptEvidence(run);
+  if (adapterEvidenceError) return failResult('orchestration-state', adapterEvidenceError);
   if (run.status === 'paused' && (!run.pause?.code || !run.pause?.message)) {
     return failResult('orchestration-state', 'Paused run requires a stable pause code and message');
   }
   if (run.status === 'completed') {
-    if (run.completionEvidence != null) {
-      const evidenceError = validateCleanCompletionEvidence(run);
-      if (evidenceError) return failResult('orchestration-state', evidenceError);
-    } else if (run.pendingDelegation !== null || !run.commitAuthorization?.consumedAt) {
-      return failResult('orchestration-state', 'Completed run must consume commit authorization and clear pending delegation');
-    }
+    const evidenceError = validateCleanCompletionEvidence(run);
+    if (evidenceError) return failResult('orchestration-state', evidenceError);
   } else if (run.completionEvidence != null) {
     return failResult('orchestration-state', 'Clean completion evidence requires a completed run');
   } else if (run.pendingDelegation?.status === 'sealed') {
@@ -206,17 +205,26 @@ function validateCleanCompletionEvidence(run: OrchestrationRun): string | null {
   if (
     run.status !== 'completed'
     || run.pendingDelegation !== null
-    || run.commitAuthorization?.issuedAt !== null
-    || run.commitAuthorization?.consumedAt !== null
     || run.receipts.some((receipt) => receipt.stage === 'commit')
   ) {
-    return 'Clean completion evidence conflicts with commit delegation state';
+    return 'Clean completion evidence conflicts with pending delegation or commit receipt state';
+  }
+  return null;
+}
+
+function validateAdapterReceiptEvidence(run: OrchestrationRun): string | null {
+  const receipts = [...run.receipts, ...(run.pendingDelegation ? [run.pendingDelegation] : [])];
+  for (const receipt of receipts) {
+    const validate = getAgentClientAdapter(receipt.client).orchestrationAdapter?.validateReceiptEvidence;
+    if (validate && !validate(receipt)) {
+      return `Receipt '${receipt.id}' has invalid evidence from its agent adapter`;
+    }
   }
   return null;
 }
 
 function checkOrchestrationEvidence({ taskDir }: any): any {
-  const file = path.join(taskDir, 'orchestration.json');
+  const file = path.join(taskDir, '.runtime', 'orchestration.json');
   const stat = safeStat(file);
   if (!stat?.isFile()) return failResult('orchestration-evidence', 'orchestration.json is missing');
   let run: OrchestrationRun | null;
@@ -227,6 +235,8 @@ function checkOrchestrationEvidence({ taskDir }: any): any {
     return failResult('orchestration-evidence', `Invalid orchestration.json: ${message}`);
   }
   if (!run) return failResult('orchestration-evidence', 'orchestration.json is missing');
+  const adapterEvidenceError = validateAdapterReceiptEvidence(run);
+  if (adapterEvidenceError) return failResult('orchestration-evidence', adapterEvidenceError);
   // readRun validates the persisted schema, receipt identities and client provenance.
   const policy = run.modelPolicy;
   if (run.completionEvidence != null) {
@@ -249,20 +259,22 @@ function checkOrchestrationEvidence({ taskDir }: any): any {
     }
     const activated = ['activated', 'stage-completed', 'sealed', 'consumed'].includes(receipt.status);
     if (activated) {
-      const isClaudeCode = receipt.client === 'claude-code';
-      if (!isClaudeCode) {
+      const evidencePolicy = getAgentClientAdapter(receipt.client).delegationEvidence;
+      if (evidencePolicy.actualModelRequired !== false) {
         if (!exactText(receipt.actualModel)) {
           return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has no host-observed actual model`);
         }
+      }
+      if (evidencePolicy.actualReasoningEffortRequired !== false) {
         if (!exactText(receipt.actualReasoningEffort)) {
           return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has no host-observed actual reasoning effort`);
         }
       }
-      if (!isClaudeCode && receipt.spawnMode !== 'fresh') {
+      if (evidencePolicy.spawnModeRequired !== false && receipt.spawnMode !== 'fresh') {
         return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has invalid fresh delegation identity`);
       }
       if (receipt.actualModel != null && receipt.actualModel !== receipt.requestedModel) {
-        if (!isClaudeCode && !exactText(receipt.modelFallbackReason)) {
+        if (evidencePolicy.fallbackReasonRequired !== false && !exactText(receipt.modelFallbackReason)) {
           return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' model fallback is not justified`);
         }
       }
@@ -273,7 +285,7 @@ function checkOrchestrationEvidence({ taskDir }: any): any {
         return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' has an unrelated model fallback reason`);
       }
       if (receipt.actualReasoningEffort != null && receipt.actualReasoningEffort !== receipt.requestedReasoningEffort) {
-        if (!isClaudeCode && !exactText(receipt.reasoningEffortFallbackReason)) {
+        if (evidencePolicy.fallbackReasonRequired !== false && !exactText(receipt.reasoningEffortFallbackReason)) {
           return failResult('orchestration-evidence', `Receipt '${receipt.id ?? '(unknown)'}' reasoning-effort fallback is not justified`);
         }
       }
@@ -790,7 +802,6 @@ function checkActivityLog({ taskDir, config, skillName, artifactFile }: any): an
   const entries = section.entries;
   if (entries.length === 0) return failResult("activity-log", "Activity Log has no entries");
 
-  let previousTimestamp = "";
   let latestAction = "";
   let latestTimestamp = "";
   const doneActions: string[] = [];
@@ -798,14 +809,8 @@ function checkActivityLog({ taskDir, config, skillName, artifactFile }: any): an
   for (const entry of entries) {
     if (!entry.note.trim()) return failResult("activity-log", "Activity Log entry note is required");
     const { time: timestamp, step: action } = entry;
-    if (previousTimestamp && timestamp < previousTimestamp) {
-      return failResult("activity-log", "Activity Log timestamps are not in ascending order");
-    }
-
-    previousTimestamp = timestamp;
-    // Ascending order is checked over every entry, but a `[started]` marker is
-    // not a terminal action: keep latestAction/latestTimestamp on the most
-    // recent done entry so expected_action_pattern sees it.
+    // A `[started]` marker is not a terminal action: keep latestAction/latestTimestamp
+    // on the most recent done entry so expected_action_pattern sees it.
     if (!ACTIVITY_LOG_STARTED_RE.test(action)) {
       latestTimestamp = timestamp;
       latestAction = action;

package/lib/task/workspace-snapshot.ts

@@ -67,7 +67,7 @@ function taskFileFingerprints(stateRoot: string, taskId: string | null): TaskFil
       return;
     }
     if (!stat.isFile() && !stat.isSymbolicLink()) return;
-    if (relative.startsWith('.agents/workspace/active/') && path.posix.basename(relative) === 'orchestration.json') return;
+    if (/^\.agents\/workspace\/(?:active|blocked|completed)\/TASK-[0-9]{8}-[0-9]{6}\/\.runtime\/orchestration\.json$/u.test(relative)) return;
     const content = stat.isSymbolicLink()
       ? Buffer.from(fs.readlinkSync(absolute))
       : fs.readFileSync(absolute);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitlab-ai/agent-infra",
-  "version": "0.11.11",
+  "version": "0.11.13",
   "description": "Bootstrap tool for AI multi-tool collaboration infrastructure — works with Claude Code, Codex, Antigravity CLI, and OpenCode",
   "license": "MIT",
   "type": "module",

package/templates/.agents/hooks/lifecycle-delegation.js

@@ -16,28 +16,6 @@ function internalCliInvocation(args) {
   return { command: 'agent-infra-internal', commandArgs: args, shell: process.platform === 'win32' };
 }
 
-function findCapabilityRef(value, depth = 0) {
-  if (depth > 5 || value == null) return '';
-  if (typeof value === 'string') {
-    const match = /agent-infra-codex-capability:([A-Za-z0-9_-]{20,})/.exec(value);
-    return match?.[1] || '';
-  }
-  if (Array.isArray(value)) {
-    for (const entry of value) {
-      const found = findCapabilityRef(entry, depth + 1);
-      if (found) return found;
-    }
-    return '';
-  }
-  if (typeof value === 'object') {
-    for (const entry of Object.values(value)) {
-      const found = findCapabilityRef(entry, depth + 1);
-      if (found) return found;
-    }
-  }
-  return '';
-}
-
 let input = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => {
@@ -77,11 +55,10 @@ process.stdin.on('end', () => {
       process.exit(1);
     }
     const managedAgent = /^agent-infra-lifecycle-(executor|reviewer)$/.test(String(nativeAgent || ''));
-    const capabilityRef = hook === 'post-tool' ? findCapabilityRef(toolResponse) : '';
     const parentReconcile = hook === 'post-tool'
       && toolName === 'collaborationwait_agent'
       && toolResponse.timed_out !== true;
-    if (!managedAgent && !parentReconcile && !capabilityRef) process.exit(0);
+    if (!managedAgent && !parentReconcile) process.exit(0);
     const hookDefinitionHash = createHash('sha256').update(readFileSync(codexHooks)).digest('hex');
     const normalized = {
       sessionId: String(event.session_id || ''),
@@ -96,7 +73,6 @@ process.stdin.on('end', () => {
       taskName: String(toolInput.task_name || ''),
       transcriptPath: String(event.transcript_path || '')
     };
-    if (capabilityRef) normalized.capabilityRef = capabilityRef;
     const args = ['codex-lifecycle', 'hook-event', '--event', hook, '--bridge', 'true'];
     try {
       const { command, commandArgs, shell } = internalCliInvocation(args);

package/templates/.agents/rules/README.en.md

@@ -9,7 +9,7 @@ so you can quickly find "which ones to read" without opening each file.
 ## General Principles
 
 - [`no-mid-flow-questions.md`](no-mid-flow-questions.md) — Question boundaries, error diagnosis order, and autonomous recovery during SKILL runs.
-- [`next-step-output.md`](next-step-output.md) — "Next step" output rules: task short-id rendering and the `Completed at` trailer.
+- [`next-step-output.md`](next-step-output.md) — "Next step" output rules: task short-id rendering, pending human decisions, and workflow warnings.
 - [`version-stamp.md`](version-stamp.md) — How and when to stamp `agent_infra_version`.
 - [`debugging-guide.md`](debugging-guide.md) — Structured debugging flow: gather evidence → form hypothesis → verify hypothesis → fix the root cause; no blind patch-and-retry.
 - [`compatibility-policy.md`](compatibility-policy.md) — Compatibility by exception: admission evidence, implementation boundaries, exit conditions, and lifecycle review requirements.
@@ -17,6 +17,7 @@ so you can quickly find "which ones to read" without opening each file.
 - [`validation-output.md`](validation-output.md) — User-facing validation summaries, failure diagnostics, soft warnings, and consumer boundaries.
 - [`sync-content-generation.md`](sync-content-generation.md) — Producer-side Markdown constraints for task and lifecycle content synchronized to Issues.
 - [`decision-qualification.md`](decision-qualification.md) — Constraint, candidate, human-confirmation, and six-artifact qualification-audit contract.
+- [`strategy-pattern.md`](strategy-pattern.md) — Identify shared flows and different behaviors, then use interfaces and the Strategy Pattern to isolate implementation differences.
 
 ## Issue / PR
 

package/templates/.agents/rules/README.zh-CN.md

@@ -8,7 +8,7 @@
 ## 通用准则
 
 - [`no-mid-flow-questions.md`](no-mid-flow-questions.md) — SKILL 执行期提问边界、错误诊断顺序和自主恢复原则。
-- [`next-step-output.md`](next-step-output.md) — 「下一步」输出规则：任务短号渲染与 `Completed at` 收尾行。
+- [`next-step-output.md`](next-step-output.md) — 「下一步」输出规则：任务短号、人工裁决提示与工作流告警。
 - [`version-stamp.md`](version-stamp.md) — `agent_infra_version` 版本戳的取值命令与写入时机。
 - [`debugging-guide.md`](debugging-guide.md) — 结构化调试流程：收集证据→形成假设→验证假设→修复根因，禁止盲目改代码重试。
 - [`compatibility-policy.md`](compatibility-policy.md) — 兼容性默认关闭：准入证据、实现边界、退出条件与生命周期审查要求。
@@ -16,6 +16,7 @@
 - [`validation-output.md`](validation-output.md) — 面向用户的校验状态摘要、失败诊断、软警告及消费边界。
 - [`sync-content-generation.md`](sync-content-generation.md) — 同步到 Issue 的任务和生命周期 Markdown 生成约束。
 - [`decision-qualification.md`](decision-qualification.md) — 约束、候选、人工确认和六类 artifact 资格审计契约。
+- [`strategy-pattern.md`](strategy-pattern.md) — 识别共用流程和不同行为，通过接口与策略模式隔离实现差异。
 
 ## Issue / PR
 

package/templates/.agents/rules/next-step-output.en.md

@@ -1,11 +1,10 @@
 # Next-Step Output Rule
 
-This file defines four **independent** rules for a skill's "notify-user / Next steps" output (the 3rd applies to review-* only); read this file before rendering the final output and apply whichever rules apply:
+This file defines three **independent** rules for a skill's "notify-user / Next steps" output (the 2nd applies to review-* only); read this file before rendering the final output and apply whichever rules apply:
 
 1. **Next-step output structure**: how "Next steps" commands and the "Task info" block present the task ID (placeholders / short-id lookup / fallback).
-2. **Agent output trailing line (Completed at)**: the **very last line** of user-facing output, **independent of the "Next steps" block**, applying to normal / error / early-return paths alike.
-3. **Pending human-decision pre-block**: applies only to `review-analysis` / `review-plan` / `review-code` when this stage has pending rulings (`{h} > 0`) — expand the pending items before the "Next steps" commands and prompt to resolve them first.
-4. **Workflow Warnings output block**: applies when task.md has `status=open` rows in `## Workflow Warnings` — print the warning summary after all normal information and "Next steps" commands, and before `Completed at`.
+2. **Pending human-decision pre-block**: applies only to `review-analysis` / `review-plan` / `review-code` when this stage has pending rulings (`{h} > 0`) — expand the pending items before the "Next steps" commands and prompt to resolve them first.
+3. **Workflow Warnings output block**: applies when task.md has `status=open` rows in `## Workflow Warnings` — print the warning summary after all normal information and "Next steps" commands.
 
 ## Placeholder semantics
 
@@ -34,7 +33,7 @@ agent-infra-internal agent-client next-steps \
 - Pass the next skill name for the already-selected scenario. Include `--task-ref` only when that command needs a task reference.
 - Include `--version` only for a versioned release command. It must start with a digit and satisfy `semver.valid(raw) === raw`; never pass an action, complete command, shell fragment, whitespace, or a `v` / `V` / `=` prefix.
 - The helper lists enabled built-in clients, followed by selected sandbox custom tools with a valid `invoke` field in `sandbox.tools.ids` order.
-- Insert non-empty stdout verbatim at `{next-step-commands}` below the current "Next steps" heading. When stdout is empty, omit the client command block while still rendering reminders, warnings, and `Completed at`.
+- Insert non-empty stdout verbatim at `{next-step-commands}` below the current "Next steps" heading. When stdout is empty, omit the client command block while still rendering reminders and warnings.
 - If the helper writes stderr or exits non-zero, use the current skill's error path and stop; never fall back to a hard-coded client table.
 - A complex skill selects one scenario first and invokes the helper once for that scenario; it must not pre-render every branch.
 
@@ -69,21 +68,9 @@ process.stdout.write(hit?hit[0]:full);
 
 Short ids are always rendered as zero-padded bare digits `NN`. The removed `#NN` syntax must neither be generated nor accepted, avoiding bash comment interpretation.
 
-## Agent output trailing line (Completed at)
-
-This section is a standalone rule, **co-equal with the next-step output structure** and **not part of the "Next steps" block**. Every skill that renders user-facing output must append the completion-time line as the **very last line** of that output — including **complete-task, which renders no next-step commands**, and **error / early-return paths** where a precondition is unmet. This lets users scanning across tmux windows tell at a glance which agent finished most recently:
-
-```text
-Completed at: YYYY-MM-DD HH:mm:ss
-```
-
-- Value command (local timezone, no offset): `date "+%Y-%m-%d %H:%M:%S"`
-- Position: it must be the last line of the entire user-facing output, after all "Next steps" commands. If a scenario has a conditional reminder line after the commands (e.g. the manual-validation reminder), the completion line goes after that reminder.
-- This line is for terminal scanning only; it is never written to any artifact file or Issue/PR comment. The single source of truth for completion time remains the Activity Log in task.md.
-
 ## Workflow Warnings Output Block
 
-If the current task's `## Workflow Warnings` / `## 工作流告警` table has any `status=open` row, the skill's final user output must append a summary block after all normal information and "Next steps" commands, and before `Completed at`. When no open warning exists, do not render this block.
+If the current task's `## Workflow Warnings` / `## 工作流告警` table has any `status=open` row, the skill's final user output must append a summary block after all normal information and "Next steps" commands. When no open warning exists, do not render this block.
 
 Format:
 
@@ -96,7 +83,7 @@ Use `[ACTION REQUIRED]` when any open row has `severity=ACTION_REQUIRED`; otherw
 
 ## Pending human-decision pre-block (review-* only, when {h} > 0)
 
-This section is a **third standalone rule, co-equal with the two above**, used only by the "notify-user / report conclusion" step of `review-analysis` / `review-plan` / `review-code`.
+This section is the **second independent rule**, used only by the "notify-user / report conclusion" step of `review-analysis` / `review-plan` / `review-code`.
 
 `{h}` has the same meaning as the count line in each review skill's `reference/output-templates.md`: the number of rows in task.md `## 审查分歧账本` (Review Disagreement Ledger) for **this stage** (`stage ∈ {analysis|plan|code}`) whose `status = needs-human-decision` — **pending items only, excluding rows already `human-decided`**.
 

package/templates/.agents/rules/next-step-output.zh-CN.md

@@ -1,11 +1,10 @@
 # 下一步输出规则
 
-本文件定义 skill「告知用户 / 下一步」输出的四类**相互独立**的规则（第 3 类仅 review-* 适用）；渲染最终输出前先读取本文件并落实其中适用的规则：
+本文件定义 skill「告知用户 / 下一步」输出的三类**相互独立**的规则（第 2 类仅 review-* 适用）；渲染最终输出前先读取本文件并落实其中适用的规则：
 
 1. **下一步输出结构**：「下一步」命令与「任务信息」段如何呈现任务 ID 形态（占位符 / 取短号 / 回退）。
-2. **Agent 输出收尾行（Completed at）**：面向用户输出的**绝对最后一行**，**独立于「下一步」块**，正常 / 错误 / 早退路径都适用。
-3. **人工裁决待办前置块**：仅 `review-analysis` / `review-plan` / `review-code`，且本阶段存在待裁决项（`{h} > 0`）时适用——在「下一步」命令前展开待裁决项并提示先完成裁决。
-4. **Workflow Warnings 输出块**：当前 task.md 存在 `status=open` 的 `## 工作流告警` 行时适用——在所有常规信息和「下一步」命令之后、`Completed at` 之前输出告警摘要。
+2. **人工裁决待办前置块**：仅 `review-analysis` / `review-plan` / `review-code`，且本阶段存在待裁决项（`{h} > 0`）时适用——在「下一步」命令前展开待裁决项并提示先完成裁决。
+3. **Workflow Warnings 输出块**：当前 task.md 存在 `status=open` 的 `## 工作流告警` 行时适用——在所有常规信息和「下一步」命令之后输出告警摘要。
 
 ## 占位符语义
 
@@ -34,7 +33,7 @@ agent-infra-internal agent-client next-steps \
 - 静态传入当前已选场景的下一 skill 名；只有命令需要任务引用时才传 `--task-ref`。
 - 只有版本化发布命令需要版本时才传 `--version`；值必须是以数字开头且 `semver.valid(raw) === raw` 的规范 SemVer。不得传 action、完整命令、shell 片段、空白或 `v` / `V` / `=` 前缀。
 - helper 展示 `.agents/.airc.json` 中 `agentClients` 已启用的内建客户端，并按 `sandbox.tools.ids` 顺序追加具有有效 `invoke` 的已选自定义沙箱工具。
-- 将非空 stdout 原样放入当前“下一步”标题后的 `{next-step-commands}`；stdout 为空时省略整个客户端命令块，但继续输出提醒、告警和 `Completed at`。
+- 将非空 stdout 原样放入当前“下一步”标题后的 `{next-step-commands}`；stdout 为空时省略整个客户端命令块，但继续输出提醒和告警。
 - helper 写 stderr 或返回非零时，按当前 skill 的错误路径报告并停止；禁止回退到硬编码客户端表。
 - 复杂 skill 先选定唯一场景，再只为该场景调用一次 helper，不得提前渲染所有分支。
 
@@ -69,21 +68,9 @@ process.stdout.write(hit?hit[0]:full);
 
 短号统一渲染为零填充裸数字 `NN`。已移除的 `#NN` 语法不得生成或接受，避免 bash 将其解释为注释。
 
-## Agent 输出收尾行（Completed at）
-
-本节是与「下一步输出结构」**并列的独立规则**，不隶属于「下一步」块。任何向用户渲染输出的 skill 都必须在面向用户输出的**绝对最后一行**追加完成时间收尾行——包括**声明「不渲染下一步命令」的 complete-task**，以及前置条件未满足而提前 return 的**错误 / 早退路径**。便于用户在 tmux 多窗口扫视时一眼判断各 Agent 的完成先后：
-
-```text
-Completed at: YYYY-MM-DD HH:mm:ss
-```
-
-- 取值命令（本地时区、不带偏移）：`date "+%Y-%m-%d %H:%M:%S"`
-- 位置：必须是整段面向用户输出的最后一行，排在所有「下一步」命令之后。若某场景在命令之后还有条件性提醒行（如 manual-validation 提醒），收尾行排在该提醒行之后。
-- 该行只用于终端扫视，不写入任何产物文件或 Issue/PR 评论；完成时刻的单一事实源仍是 task.md 的 Activity Log。
-
 ## Workflow Warnings 输出块
 
-若当前任务的 `## 工作流告警` / `## Workflow Warnings` 表中存在 `status=open` 行，skill 最终输出必须在所有常规信息和「下一步」命令之后、`Completed at` 之前追加摘要块；无 open 告警时不输出本块。
+若当前任务的 `## 工作流告警` / `## Workflow Warnings` 表中存在 `status=open` 行，skill 最终输出必须在所有常规信息和「下一步」命令之后追加摘要块；无 open 告警时不输出本块。
 
 格式：
 
@@ -96,7 +83,7 @@ Completed at: YYYY-MM-DD HH:mm:ss
 
 ## 人工裁决待办前置块（review-* 专用，{h} > 0 时）
 
-本节是与上面两类规则**并列的第三类独立规则**，仅 `review-analysis` / `review-plan` / `review-code` 的「向用户汇报结论」步骤使用。
+本节是与下一步输出结构并列的第二类规则，仅 `review-analysis` / `review-plan` / `review-code` 的「向用户汇报结论」步骤使用。
 
 `{h}` 含义与各 review 技能 `reference/output-templates.md` 计数行一致：task.md `## 审查分歧账本` 中**本阶段**（`stage ∈ {analysis|plan|code}`）`status = needs-human-decision` 的行数——**只含待裁决项，不含已 `human-decided`**。
 

package/templates/.agents/rules/strategy-pattern.en.md

@@ -0,0 +1,25 @@
+# Strategy Pattern
+
+This rule applies during technical design and implementation. When behavior differs by platform, client, protocol, workflow, business rule, or algorithm, use interfaces to isolate implementations so shared flows can reuse them instead of creating a dedicated path for every scenario.
+
+## Design Steps
+
+1. **Separate shared flows from different implementations**: identify common steps and the behavior that differs by platform, client, protocol, workflow, business rule, algorithm, or lifecycle.
+2. **Define the interface contract**: specify the inputs, outputs, error semantics, and invocation timing shared by implementations. The common flow depends on the interface, not a concrete implementation.
+3. **Apply the Strategy Pattern**: provide an implementation for each behavior and select a strategy at registration or assembly. The common flow orchestrates shared steps without spreading conditions that identify concrete implementations.
+4. **Verify substitutability**: a new implementation should connect through registration or assembly. Write shared tests for the interface contract and the necessary tests for strategy selection and full assembly.
+
+## Implementation Requirements
+
+- When the requirement clearly includes multiple behaviors, prefer the Strategy Pattern even if there is currently one implementation; the interface should express their stable shared contract.
+- When adding behavior, prefer adding a strategy implementation and registering or assembling it in one place. Do not copy a full business flow or repeat the same branch across callers.
+- If branches that identify implementations are already scattered across paths, consolidate those decisions at strategy selection and make callers depend on the interface.
+- Reuse existing interfaces and domain terms. Do not rename code to apply a pattern or add interfaces to stable behavior that has no meaningful alternatives.
+- Keep stable, single-purpose behavior direct when there is no evidence it will vary. Do not mechanically add interfaces, configuration, or extension points.
+
+## Design Review Questions
+
+- Which steps are shared by all implementations, and which behaviors differ by platform, client, or business rule?
+- Does the interface express the contract shared by the implementations?
+- Can a new behavior be added by implementing a strategy and assembling it in one place? If several call paths must change, is centralized strategy selection missing?
+- Can the same interface tests validate the shared contract while strategy differences are tested independently?

package/templates/.agents/rules/strategy-pattern.zh-CN.md

@@ -0,0 +1,25 @@
+# 策略模式
+
+本规则适用于方案设计和代码实现。当平台、客户端、协议、工作流、业务规则或算法存在多种行为时，用接口隔离这些实现，让共用流程能够复用不同实现，避免每种场景都形成一条专用链路。
+
+## 设计步骤
+
+1. **区分共用流程和不同实现**：找出所有实现共同执行的步骤，以及会因平台、客户端、协议、工作流、业务规则、算法或生命周期而不同的行为。
+2. **定义接口契约**：明确不同实现的输入、输出、错误语义和调用时机。共用流程依赖接口，不直接调用某个具体实现。
+3. **应用策略模式**：为每种行为提供独立实现，在注册或装配处选择策略。共用流程负责编排共同步骤，不散布识别具体实现的条件分支。
+4. **验证实现可替换**：新增实现应能通过注册或装配接入；为接口约定编写共享测试，并为策略选择和整体装配编写必要测试。
+
+## 实现要求
+
+- 需求明确包含多种行为时，优先使用策略模式，即使当前只有一个实现；接口应表达这些实现之间稳定的共同约定。
+- 新增行为时，优先增加一个策略实现并在统一位置注册或装配，不复制完整业务链，也不在多个调用方重复增加同类分支。
+- 如果识别不同实现的分支已经散落在多条路径，先把这些判断收敛到策略选择处，再让调用方依赖接口。
+- 复用现有接口和领域词汇；不要为了套用模式而改名，也不要为没有不同行为的稳定逻辑增加接口。
+- 对稳定、单一且没有证据表明会变化的逻辑，保持直接实现，不机械添加接口、配置或扩展点。
+
+## 设计审查问题
+
+- 所有实现共用哪些流程？哪些行为因平台、客户端或业务规则而不同？
+- 接口是否表达了不同实现共同遵守的约定？
+- 新实现能否只新增策略并在一个位置装配？如果必须修改多处调用链，是否缺少统一的策略选择？
+- 共用约定能否通过同一套接口测试验证，不同策略的差异能否独立验证？

package/templates/.agents/skills/analyze-task/SKILL.en.md

@@ -120,7 +120,7 @@ Runs after Step 0 state check and Step 3 (questioning is an external-state actio
   2. If `start_date` is empty, write today (`date +%F`), then run `agent-infra-internal task-event {task-id} analyze.awaiting-input --agent {standard-agent-token} --question {question_count}` so the core updates base metadata and Activity Log.
   3. Issue sync (when a valid `platform_issue_identity` exists, skip on any failure): run `agent-infra-internal platform-comment sync {task-id} --kind task --agent {standard-agent-token}` to update only the **task comment**; keep the `status` label at `pending-design-work`; do **not** publish an analysis artifact comment.
   4. Verification (replaces the step 8 artifact gate): `agent-infra-internal task-verify {task-id} analyze.awaiting-input --format text` (the early-exit set `current_step: requirement-analysis` and wrote `start_date`, so it should pass); also keep `rg -n 'Analyze Task \(Brainstorming\)' .agents/workspace/active/{task-id}/task.md` and the task-comment sync evidence. Do **not** run the artifact gate, nor `check activity-log` / `check platform-sync` (both bind to the analysis artifact path).
-  5. User output: show only the current **single question** plus how to answer/continue (re-trigger `analyze-task {task-ref}` with the answer), and append the `Completed at` line per `.agents/rules/next-step-output.md`.
+  5. User output: show only the current **single question** plus how to answer/continue (re-trigger `analyze-task {task-ref}` with the answer).
   6. **STOP** and wait for the answer. The next trigger returns to this step.
 
 ### 5. Perform Requirements Analysis

package/templates/.agents/skills/analyze-task/SKILL.zh-CN.md

@@ -123,7 +123,7 @@ agent-infra-internal task-event {task-id} analyze.started --agent {standard-agen
   2. 若 `start_date` 为空，写入当日日期（`date +%F`）；随后执行 `agent-infra-internal task-event {task-id} analyze.awaiting-input --agent {standard-agent-token} --question {question_count}`，由核心统一更新基础 frontmatter 和 Activity Log。
   3. Issue 同步（存在有效 `platform_issue_identity` 时，任一失败跳过）：调用 `agent-infra-internal platform-comment sync {task-id} --kind task --agent {standard-agent-token}` 更新 **task 评论**；`status` label 维持 `pending-design-work`；**不**发布分析产物评论。
   4. 校验（替代步骤 8 的 artifact gate）：`agent-infra-internal task-verify {task-id} analyze.awaiting-input --format text`（早退已置 `current_step: requirement-analysis` 且已写入 `start_date`，预期通过）；并保留 `rg -n 'Analyze Task \(Brainstorming\)' .agents/workspace/active/{task-id}/task.md` 与 task 评论同步证据。**不**跑 artifact gate，也不跑 `check activity-log` / `check platform-sync`（二者绑定分析产物路径）。
-  5. 用户输出：只展示当前**单个问题** + 如何回答/继续（再次触发 `analyze-task {task-ref}` 并附答案），并按 `.agents/rules/next-step-output.md` 在末行追加 `Completed at`。
+  5. 用户输出：只展示当前**单个问题** + 如何回答/继续（再次触发 `analyze-task {task-ref}` 并附答案）。
   6. **STOP**，等待回答。下一次触发回到本步骤。
 
 ### 5. 执行需求分析

package/templates/.agents/skills/check-task/SKILL.en.md

@@ -70,7 +70,7 @@ When the action is non-empty, perform only this literal action-to-skill conversi
 | `code` | `code-task` |
 | any other action | same-named skill |
 
-When the action is empty, do not invoke the helper; state that no next skill is currently recommended. Before rendering the final output, read `.agents/rules/next-step-output.md`; invoke `agent-infra-internal agent-client next-steps --skill {next-skill} --task-ref {task-ref}` and render stdout verbatim as `{next-step-commands}`. Append the `Completed at` trailing line last.
+When the action is empty, do not invoke the helper; state that no next skill is currently recommended. Before rendering the final output, read `.agents/rules/next-step-output.md`; invoke `agent-infra-internal agent-client next-steps --skill {next-skill} --task-ref {task-ref}` and render stdout verbatim as `{next-step-commands}`.
 
 ## Notes
 

package/templates/.agents/skills/check-task/SKILL.zh-CN.md

@@ -70,7 +70,7 @@ ai task status --task {task-id}
 | `code` | `code-task` |
 | 其他 action | 同名 skill |
 
-`action` 为空时不调用 helper，只说明当前没有可推荐的下一技能。渲染最终输出前先读取 `.agents/rules/next-step-output.md`；helper 命令为 `agent-infra-internal agent-client next-steps --skill {next-skill} --task-ref {task-ref}`，stdout 原样作为 `{next-step-commands}` 下一步命令。最后追加 `Completed at` 收尾行。
+`action` 为空时不调用 helper，只说明当前没有可推荐的下一技能。渲染最终输出前先读取 `.agents/rules/next-step-output.md`；helper 命令为 `agent-infra-internal agent-client next-steps --skill {next-skill} --task-ref {task-ref}`，stdout 原样作为 `{next-step-commands}` 下一步命令。
 
 ## 注意事项
 

package/templates/.agents/skills/code-task/SKILL.en.md

@@ -187,4 +187,4 @@ Present the verification summary per `.agents/rules/validation-output.md`, retai
 
 Use `reference/output-template.md` (or `reference/fix-mode.md` in fix mode) and render the selected next-step commands through the shared helper. The local checkpoint is required for this skill; do not invoke the standalone `commit` skill, push, or create a PR here.
 
-> Before rendering the final output, read `.agents/rules/next-step-output.md` and apply both of its rules: (1) render `{task-ref}` in the "Next steps" commands as the current task's short id `NN` (see that file for lookup and fallback), while other `{task-id}` placeholders (report titles, paths) keep the full TASK-id form; (2) append the `Completed at` line as the very last line of the user-facing output (this applies to every user-facing output — success, error, and early-return paths alike, not only the success path).
+> Before rendering the final output, read `.agents/rules/next-step-output.md`; render `{task-ref}` in the "Next steps" commands as the current task's short id `NN` (see that file for lookup and fallback), while other `{task-id}` placeholders (report titles, paths) keep the full TASK-id form.

package/templates/.agents/skills/code-task/SKILL.zh-CN.md

@@ -241,7 +241,7 @@ agent-infra-internal task-verify {task-id} code.completed --artifact {code-artif
 
 > 渲染下一步前先读取 `.agents/rules/next-step-output.md`，并按 `reference/output-template.md` 或 `reference/fix-mode.md` 的已选场景调用统一 helper。
 
-> 渲染最终输出前先读取 `.agents/rules/next-step-output.md` 并落实其两类规则：(1) 「下一步」命令的 `{task-ref}` 渲染为当前任务短号 `NN`（取值与回退见该文件），其他 `{task-id}` 占位（报告标题、路径）保持完整 TASK-id 形式；(2) 在面向用户输出的绝对最后一行追加 `Completed at` 收尾行（成功、错误、早退等任何面向用户输出都适用，不限于校验通过的成功态）。
+> 渲染最终输出前先读取 `.agents/rules/next-step-output.md`，并将「下一步」命令的 `{task-ref}` 渲染为当前任务短号 `NN`（取值与回退见该文件）；其他 `{task-id}` 占位（报告标题、路径）保持完整 TASK-id 形式。
 
 ## 完成检查清单