@fitlab-ai/agent-infra 0.8.2 → 0.8.4

package/templates/.agents/scripts/platform-adapters/platform-sync.github.js

@@ -112,6 +112,7 @@ export function check({ taskDir, config, artifactFile }, shared) {
     checkCommentMarker,
     checkPrCommentMarker,
     checkPrCommentLastCommit,
+    checkPrCommentRequiredPatterns,
     checkCommentContent,
     checkTaskCommentContent,
     checkInLabelsComputed,
@@ -158,6 +159,7 @@ function buildSyncContext({ taskDir, config, artifactFile }) {
     return { earlyReturn: blockedResult(CHECK_TYPE, upstreamRepo.message, "network_error") };
   }
   const permissions = detectPermissions(upstreamRepo.value, taskDir);
+  const repoOwnerType = detectRepoOwnerType(upstreamRepo.value, taskDir);
   const expectedValues = resolveExpectedValues(config);
   if (!expectedValues.ok) {
     return { earlyReturn: failResult(CHECK_TYPE, expectedValues.message, "check_failed") };
@@ -180,6 +182,7 @@ function buildSyncContext({ taskDir, config, artifactFile }) {
     issueNumber,
     prNumber,
     upstreamRepo: upstreamRepo.value,
+    repoOwnerType,
     hasTriage: permissions.hasTriage,
     hasPush: permissions.hasPush,
     expectedStatusLabel: expectedValues.statusLabel,
@@ -553,6 +556,41 @@ function checkPrCommentLastCommit(context, remoteData) {
   );
 }
 
+function checkPrCommentRequiredPatterns(context, remoteData) {
+  const patterns = context.config.expected_pr_comment_required_patterns || [];
+  if (!Array.isArray(patterns) || patterns.length === 0) {
+    return null;
+  }
+
+  if (!context.prMarker) {
+    return failResult(CHECK_TYPE,
+      "expected_pr_comment_required_patterns requires expected_pr_comment_marker",
+      "check_failed"
+    );
+  }
+
+  const comment = findCommentByMarker(remoteData.prComments, context.prMarker);
+  if (!comment) {
+    return failResult(CHECK_TYPE,
+      `Expected PR comment marker '${context.prMarker}' not found on PR #${context.prNumber}`,
+      "check_failed"
+    );
+  }
+
+  const body = String(comment.body || "");
+  for (const pattern of patterns) {
+    const regex = new RegExp(pattern, "m");
+    if (!regex.test(body)) {
+      return failResult(CHECK_TYPE,
+        `PR #${context.prNumber} summary comment is missing required pattern: ${pattern}`,
+        "check_failed"
+      );
+    }
+  }
+
+  return null;
+}
+
 function checkCommentContent(context, remoteData) {
   if (!context.config.verify_comment_content) {
     return null;
@@ -722,6 +760,10 @@ function checkIssueType(context, remoteData) {
   }
 
   if (!remoteData.issueType) {
+    if (context.repoOwnerType === "User") {
+      return null;
+    }
+
     return failResult(CHECK_TYPE,
       `Issue #${context.issueNumber} has no Issue Type set`,
       "check_failed"
@@ -1228,6 +1270,21 @@ function detectPermissions(upstreamRepo, taskDir) {
   };
 }
 
+function detectRepoOwnerType(upstreamRepo, taskDir) {
+  const ownerTypeResult = withRetry(() => ghText([
+    "api",
+    `repos/${upstreamRepo}`,
+    "--jq",
+    ".owner.type // empty"
+  ], taskDir));
+
+  if (!ownerTypeResult.ok) {
+    return "unknown";
+  }
+
+  return ownerTypeResult.value || "unknown";
+}
+
 function ghJson(args, cwd) {
   const result = ghCommand(args, cwd);
   if (!result.ok) {

package/templates/.agents/scripts/validate-artifact.js

@@ -6,7 +6,9 @@ import { fileURLToPath } from "node:url";
 
 import {
   extractReviewBaseline,
+  extractReviewDiffFingerprint,
   findAuthoritativeReviewCodeArtifact,
+  parseReviewVerdict,
   resolvePostReviewGlobs
 } from "./lib/post-review-commit.js";
 
@@ -61,6 +63,10 @@ const LEDGER_TERMINAL_OK = new Set(["confirmed", "closed", "human-decided"]);
 const DEFAULT_MAX_HANDSHAKE_ROUNDS = 3;
 const POST_REVIEW_COMMIT_STAGE = "post-review-commit";
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
+const WORKFLOW_WARNING_SECTION_NAMES = ["工作流告警", "Workflow Warnings"];
+const WORKFLOW_WARNING_STATUSES = new Set(["open", "resolved", "ignored"]);
+const WORKFLOW_WARNING_SEVERITIES = new Set(["IMPORTANT", "ACTION_REQUIRED"]);
+const WORKFLOW_WARNING_ID_PATTERN = /^WW-\d+$/;
 
 const scriptPath = fileURLToPath(import.meta.url);
 const repoRoot = path.resolve(path.dirname(scriptPath), "..", "..");
@@ -219,6 +225,8 @@ function runCheck(type, context) {
       return checkCompletionChecklist(context);
     case "review-ledger":
       return checkReviewLedger(context);
+    case "review-fact":
+      return checkReviewFact(context);
     case "post-review-commit":
       return checkPostReviewCommit(context);
     default: {
@@ -284,6 +292,11 @@ function checkTaskMeta({ taskDir, config }) {
     return failResult("task-meta", branchValidationError);
   }
 
+  const warningValidationErrors = validateWorkflowWarnings(task.content);
+  if (warningValidationErrors.length > 0) {
+    return failResult("task-meta", `Invalid Workflow Warnings: ${warningValidationErrors.join("; ")}`);
+  }
+
   const expectedStep = config.expected_step;
   if (expectedStep && metadata.current_step !== expectedStep) {
     return failResult(
@@ -561,6 +574,117 @@ function parseLedgerRows(section) {
   return rows;
 }
 
+function splitMarkdownTableRow(line) {
+  let value = String(line || "").trim();
+  if (!value.startsWith("|")) {
+    return [];
+  }
+  value = value.replace(/^\|/, "").replace(/\|$/, "");
+
+  const cells = [];
+  let cell = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === "|" && !isEscapedAt(value, index)) {
+      cells.push(unescapeMarkdownTableCell(cell.trim()));
+      cell = "";
+      continue;
+    }
+    cell += char;
+  }
+  cells.push(unescapeMarkdownTableCell(cell.trim()));
+  return cells;
+}
+
+function unescapeMarkdownTableCell(value) {
+  let output = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    const next = value[index + 1];
+    if (char === "\\" && (next === "\\" || next === "|")) {
+      output += next;
+      index += 1;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+function isEscapedAt(value, index) {
+  let backslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+
+function parseWorkflowWarningRows(section) {
+  const rows = [];
+  for (const rawLine of String(section || "").split(/\r?\n/)) {
+    const cells = splitMarkdownTableRow(rawLine);
+    if (cells.length === 0) {
+      continue;
+    }
+    if ((cells[0] || "").toLowerCase() === "id") {
+      continue;
+    }
+    if (cells.every((cell) => /^:?-{3,}:?$/.test(cell))) {
+      continue;
+    }
+    rows.push(cells);
+  }
+  return rows;
+}
+
+function validateWorkflowWarnings(content) {
+  const section = getSectionContent(content, WORKFLOW_WARNING_SECTION_NAMES);
+  if (!section.trim()) {
+    return [];
+  }
+
+  const rows = parseWorkflowWarningRows(section);
+  const errors = [];
+  for (const cells of rows) {
+    if (cells.length < 11) {
+      errors.push(`malformed row (expected 11 columns): ${cells.join(" | ")}`);
+      continue;
+    }
+    const [id, time, step, severity, code, status, target, message, action, resolvedAt, resolution] = cells;
+    if (!WORKFLOW_WARNING_ID_PATTERN.test(id)) {
+      errors.push(`${id || "(empty id)"}: invalid id`);
+    }
+    if (!DATE_TIME_PATTERN.test(time)) {
+      errors.push(`${id}: invalid time '${time}'`);
+    }
+    if (isBlank(step)) {
+      errors.push(`${id}: step is required`);
+    }
+    if (!WORKFLOW_WARNING_SEVERITIES.has(severity)) {
+      errors.push(`${id}: illegal severity '${severity}'`);
+    }
+    if (isBlank(code)) {
+      errors.push(`${id}: code is required`);
+    }
+    if (!WORKFLOW_WARNING_STATUSES.has(status)) {
+      errors.push(`${id}: illegal status '${status}'`);
+    }
+    if (isBlank(target)) {
+      errors.push(`${id}: target is required`);
+    }
+    if (isBlank(message)) {
+      errors.push(`${id}: message is required`);
+    }
+    if (status === "open" && isBlank(action)) {
+      errors.push(`${id}: open warning requires action`);
+    }
+    if ((status === "resolved" || status === "ignored") && (isBlank(resolvedAt) || isBlank(resolution))) {
+      errors.push(`${id}: ${status} warning requires resolved_at and resolution`);
+    }
+  }
+  return errors;
+}
+
 function resolveReviewSetting(config, key, fallback) {
   if (config && config[key] !== undefined && config[key] !== null) {
     return config[key];
@@ -698,6 +822,95 @@ function checkPostReviewCommit({ taskDir, config }) {
   );
 }
 
+function checkReviewFact({ taskDir, artifactFile }) {
+  const resolvedArtifact = resolveArtifactPath(
+    taskDir,
+    "review-code.md|review-code-r{N}.md",
+    artifactFile
+  );
+  if (!resolvedArtifact.ok) {
+    return failResult("review-fact", resolvedArtifact.message);
+  }
+
+  const task = loadTask(taskDir);
+  if (!task.ok) {
+    return failResult("review-fact", task.message);
+  }
+
+  const content = fs.readFileSync(resolvedArtifact.path, "utf8");
+  const verdict = parseReviewVerdict(content);
+  const reviewBaseline = extractReviewBaseline(content);
+  const reviewedFingerprint = extractReviewDiffFingerprint(content);
+
+  if (!["通过", "需要修改", "拒绝", "Approved", "Changes Requested", "Rejected"].includes(verdict)) {
+    return failResult("review-fact", `Unsupported review verdict '${verdict}'`);
+  }
+
+  let gitRoot;
+  let head;
+  let baseline;
+  try {
+    gitRoot = execFileSync("git", ["-C", taskDir, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
+    head = execFileSync("git", ["-C", gitRoot, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
+    baseline = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewBaseline}^{commit}`], { encoding: "utf8" }).trim();
+  } catch {
+    return blockedResult(
+      "review-fact",
+      `Unable to resolve review baseline '${reviewBaseline}' in the task repository; re-run review-code`
+    );
+  }
+
+  if (baseline !== head) {
+    return failResult(
+      "review-fact",
+      `Review baseline ${baseline.slice(0, 8)} does not match current HEAD ${head.slice(0, 8)}; re-run review-code`
+    );
+  }
+
+  let actualFingerprint;
+  try {
+    actualFingerprint = execFileSync(
+      process.execPath,
+      [path.join(repoRoot, ".agents", "scripts", "review-diff-fingerprint.js"), "worktree", baseline],
+      { cwd: gitRoot, encoding: "utf8" }
+    ).trim();
+  } catch {
+    return blockedResult(
+      "review-fact",
+      `Unable to recompute reviewed diff fingerprint from baseline ${baseline.slice(0, 8)}; re-run review-code`
+    );
+  }
+
+  if (actualFingerprint !== reviewedFingerprint) {
+    return failResult(
+      "review-fact",
+      `Reviewed diff fingerprint does not match the current worktree for baseline ${baseline.slice(0, 8)}; re-run review-code`
+    );
+  }
+
+  if (["通过", "Approved"].includes(verdict)) {
+    const lastReviewedCommit = String(task.metadata.last_reviewed_commit || "").trim();
+    let reviewedCommit = "";
+    try {
+      reviewedCommit = execFileSync("git", ["-C", gitRoot, "rev-parse", `${lastReviewedCommit}^{commit}`], { encoding: "utf8" }).trim();
+    } catch {
+      // The failure below names the missing or invalid task review fact.
+    }
+
+    if (reviewedCommit !== baseline) {
+      return failResult(
+        "review-fact",
+        `Approved review must set task last_reviewed_commit to baseline ${baseline.slice(0, 8)}`
+      );
+    }
+  }
+
+  return passResult(
+    "review-fact",
+    `Review fact valid for ${path.basename(resolvedArtifact.path)} at ${baseline.slice(0, 8)}`
+  );
+}
+
 function resolvePostReviewBaseline({ gitRoot, lastReviewedCommit, reviewBaseline, reviewArtifact }) {
   if (lastReviewedCommit) {
     if (SHA_PATTERN.test(lastReviewedCommit) && gitCommitExists(gitRoot, lastReviewedCommit)) {

package/templates/.agents/scripts/workflow-warnings.js

@@ -0,0 +1,290 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+const SECTION_ZH = "工作流告警";
+const SECTION_EN = "Workflow Warnings";
+const ACTIVITY_ZH = "活动日志";
+const ACTIVITY_EN = "Activity Log";
+const HEADER = "| id | time | step | severity | code | status | target | message | action | resolved_at | resolution |";
+const SEPARATOR = "|----|------|------|----------|------|--------|--------|---------|--------|-------------|------------|";
+const VALID_SEVERITIES = new Set(["IMPORTANT", "ACTION_REQUIRED"]);
+const VALID_STATUSES = new Set(["open", "resolved", "ignored"]);
+
+function usage() {
+  process.stderr.write([
+    "Usage:",
+    "  node .agents/scripts/workflow-warnings.js add <task-dir> --step <step> --severity <IMPORTANT|ACTION_REQUIRED> --code <code> --target <target> --message <message> --action <action>",
+    "  node .agents/scripts/workflow-warnings.js set-status <task-dir> --id <WW-N> --status <resolved|ignored> --resolution <reason>",
+    "  node .agents/scripts/workflow-warnings.js list <task-dir> [--status <status>] [--format json|text]",
+    ""
+  ].join("\n"));
+  process.exit(2);
+}
+
+function parseOptions(args) {
+  const options = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const key = args[index];
+    if (!key?.startsWith("--")) usage();
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith("--")) usage();
+    options[key.slice(2)] = value;
+    index += 1;
+  }
+  return options;
+}
+
+function timestamp() {
+  const date = new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absolute = Math.abs(offsetMinutes);
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}${sign}${pad(Math.floor(absolute / 60))}:${pad(absolute % 60)}`;
+}
+
+function escapeCell(value) {
+  return String(value ?? "").replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+
+function unescapeCell(value) {
+  const text = String(value ?? "");
+  let output = "";
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    const next = text[index + 1];
+    if (char === "\\" && (next === "\\" || next === "|")) {
+      output += next;
+      index += 1;
+      continue;
+    }
+    output += char;
+  }
+  return output;
+}
+
+function isEscapedAt(value, index) {
+  let backslashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor -= 1) {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+
+function splitRow(line) {
+  let value = String(line || "").trim();
+  if (!value.startsWith("|")) return [];
+  value = value.replace(/^\|/, "").replace(/\|$/, "");
+  const cells = [];
+  let cell = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === "|" && !isEscapedAt(value, index)) {
+      cells.push(unescapeCell(cell.trim()));
+      cell = "";
+      continue;
+    }
+    cell += char;
+  }
+  cells.push(unescapeCell(cell.trim()));
+  return cells;
+}
+
+function rowToWarning(cells, lineIndex) {
+  return {
+    lineIndex,
+    id: cells[0] || "",
+    time: cells[1] || "",
+    step: cells[2] || "",
+    severity: cells[3] || "",
+    code: cells[4] || "",
+    status: cells[5] || "",
+    target: cells[6] || "",
+    message: cells[7] || "",
+    action: cells[8] || "",
+    resolved_at: cells[9] || "",
+    resolution: cells[10] || ""
+  };
+}
+
+function warningToLine(warning) {
+  return [
+    warning.id,
+    warning.time,
+    warning.step,
+    warning.severity,
+    warning.code,
+    warning.status,
+    warning.target,
+    warning.message,
+    warning.action,
+    warning.resolved_at,
+    warning.resolution
+  ].map(escapeCell).join(" | ").replace(/^/, "| ").replace(/$/, " |");
+}
+
+function findSection(lines) {
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (new RegExp(`^##\\s+(${SECTION_ZH}|${SECTION_EN})\\s*$`).test(lines[index].trim())) {
+      start = index;
+      break;
+    }
+  }
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    if (/^##\s+/.test(lines[index])) {
+      end = index;
+      break;
+    }
+  }
+  return { start, end };
+}
+
+function insertSection(content) {
+  const lines = content.split(/\r?\n/);
+  const existing = findSection(lines);
+  if (existing) return { content, section: existing };
+
+  const activityIndex = lines.findIndex((line) => {
+    const trimmed = line.trim();
+    return trimmed === `## ${ACTIVITY_ZH}` || trimmed === `## ${ACTIVITY_EN}`;
+  });
+  const heading = content.includes(`## ${ACTIVITY_EN}`) ? SECTION_EN : SECTION_ZH;
+  const block = [`## ${heading}`, "", "<!-- Workflow degradation, platform sync failures, permission gaps, and related events. Keep the header when empty. -->", "", HEADER, SEPARATOR, ""];
+  const insertAt = activityIndex >= 0 ? activityIndex : lines.length;
+  lines.splice(insertAt, 0, ...block);
+  const updated = lines.join("\n");
+  return { content: updated, section: findSection(updated.split(/\r?\n/)) };
+}
+
+function readTask(taskDir) {
+  const taskPath = path.join(taskDir, "task.md");
+  if (!fs.existsSync(taskPath)) {
+    throw new Error(`Task file not found: ${taskPath}`);
+  }
+  return { taskPath, content: fs.readFileSync(taskPath, "utf8") };
+}
+
+function parseWarnings(content) {
+  const lines = content.split(/\r?\n/);
+  const section = findSection(lines);
+  if (!section) return [];
+  const warnings = [];
+  for (let index = section.start + 1; index < section.end; index += 1) {
+    const cells = splitRow(lines[index]);
+    if (cells.length === 0) continue;
+    if ((cells[0] || "").toLowerCase() === "id") continue;
+    if (cells.every((cell) => /^:?-{3,}:?$/.test(cell))) continue;
+    if (cells.length < 11) continue;
+    warnings.push(rowToWarning(cells, index));
+  }
+  return warnings;
+}
+
+function nextId(warnings) {
+  const max = warnings.reduce((current, warning) => {
+    const match = /^WW-(\d+)$/.exec(warning.id);
+    return match ? Math.max(current, Number.parseInt(match[1], 10)) : current;
+  }, 0);
+  return `WW-${max + 1}`;
+}
+
+function requireOption(options, key) {
+  const value = options[key];
+  if (!value) usage();
+  return value;
+}
+
+function add(taskDir, options) {
+  const severity = requireOption(options, "severity");
+  if (!VALID_SEVERITIES.has(severity)) throw new Error(`Invalid severity: ${severity}`);
+  const step = requireOption(options, "step");
+  const code = requireOption(options, "code");
+  const target = requireOption(options, "target");
+  const message = requireOption(options, "message");
+  const action = requireOption(options, "action");
+
+  const task = readTask(taskDir);
+  const inserted = insertSection(task.content);
+  const lines = inserted.content.split(/\r?\n/);
+  const warnings = parseWarnings(inserted.content);
+  const duplicate = warnings.find((warning) =>
+    warning.status === "open" &&
+    warning.step === step &&
+    warning.code === code &&
+    warning.target === target
+  );
+  if (duplicate) {
+    process.stdout.write(`${JSON.stringify({ created: false, warning: duplicate }, null, 2)}\n`);
+    if (inserted.content !== task.content) fs.writeFileSync(task.taskPath, inserted.content, "utf8");
+    return;
+  }
+
+  const warning = {
+    id: nextId(warnings),
+    time: timestamp(),
+    step,
+    severity,
+    code,
+    status: "open",
+    target,
+    message,
+    action,
+    resolved_at: "",
+    resolution: ""
+  };
+  lines.splice(inserted.section.end - 1, 0, warningToLine(warning));
+  fs.writeFileSync(task.taskPath, lines.join("\n"), "utf8");
+  process.stdout.write(`${JSON.stringify({ created: true, warning }, null, 2)}\n`);
+}
+
+function setStatus(taskDir, options) {
+  const id = requireOption(options, "id");
+  const status = requireOption(options, "status");
+  if (!["resolved", "ignored"].includes(status)) throw new Error(`Invalid status for set-status: ${status}`);
+  const resolution = requireOption(options, "resolution");
+  const task = readTask(taskDir);
+  const lines = task.content.split(/\r?\n/);
+  const warnings = parseWarnings(task.content);
+  const warning = warnings.find((candidate) => candidate.id === id);
+  if (!warning) throw new Error(`Warning not found: ${id}`);
+  warning.status = status;
+  warning.resolved_at = timestamp();
+  warning.resolution = resolution;
+  lines[warning.lineIndex] = warningToLine(warning);
+  fs.writeFileSync(task.taskPath, lines.join("\n"), "utf8");
+  process.stdout.write(`${JSON.stringify({ updated: true, warning }, null, 2)}\n`);
+}
+
+function list(taskDir, options) {
+  const format = options.format || "text";
+  const status = options.status || "";
+  if (format !== "json" && format !== "text") usage();
+  const warnings = parseWarnings(readTask(taskDir).content)
+    .filter((warning) => !status || warning.status === status)
+    .map(({ lineIndex: _lineIndex, ...warning }) => warning);
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify({ warnings }, null, 2)}\n`);
+    return;
+  }
+  for (const warning of warnings) {
+    process.stdout.write(`${warning.id} [${warning.severity}] ${warning.code} ${warning.target} - ${warning.action}\n`);
+  }
+}
+
+try {
+  const [command, taskDirArg, ...rest] = process.argv.slice(2);
+  if (!command || !taskDirArg) usage();
+  const taskDir = path.resolve(taskDirArg);
+  const options = parseOptions(rest);
+  if (command === "add") add(taskDir, options);
+  else if (command === "set-status") setStatus(taskDir, options);
+  else if (command === "list") list(taskDir, options);
+  else usage();
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+}

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

@@ -210,7 +210,7 @@ Create `.agents/workspace/active/{task-id}/{analysis-artifact}`.
 Get the current time:
 
 ```bash
-date "+%Y-%m-%d %H:%M:%S%:z"
+date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 ```
 
 Update `.agents/workspace/active/{task-id}/task.md`:

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

@@ -209,7 +209,7 @@ tail .agents/workspace/active/{task-id}/task.md
 获取当前时间：
 
 ```bash
-date "+%Y-%m-%d %H:%M:%S%:z"
+date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 ```
 
 更新 `.agents/workspace/active/{task-id}/task.md`：
@@ -275,7 +275,7 @@ node .agents/scripts/validate-artifact.js gate analyze-task .agents/workspace/ac
 
 下一步 - 审查需求分析：
   - Claude Code / OpenCode：/review-analysis {task-ref}
-  - Gemini CLI：/agent-infra:review-analysis {task-ref}
+  - Gemini CLI：/{{project}}:review-analysis {task-ref}
   - Codex CLI：$review-analysis {task-ref}
 ```
 

package/templates/.agents/skills/archive-tasks/scripts/archive-tasks.sh

@@ -210,7 +210,7 @@ rebuild_manifest() {
   entries_file="$tmpdir/manifest.tsv"
   month_keys_file="$tmpdir/manifest-months.tsv"
   year_keys_file="$tmpdir/manifest-years.tsv"
-  generated_at=$(date "+%Y-%m-%d %H:%M:%S%:z")
+  generated_at=$(date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/')
 
   mkdir -p "$ARCHIVE_DIR"
   : > "$entries_file"

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

@@ -58,7 +58,7 @@ Before blocking, thoroughly analyze:
 Get the current time:
 
 ```bash
-date "+%Y-%m-%d %H:%M:%S%:z"
+date "+%Y-%m-%d %H:%M:%S%z" | sed 's/\([+-][0-9][0-9]\)\([0-9][0-9]\)$/\1:\2/'
 ```
 
 Update `.agents/workspace/active/{task-id}/task.md`: