agent-handoff 0.2.0 → 0.4.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { createRequire } from "module";
-import { Command as Command7 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/cli/commands/init.ts
 import { Command } from "commander";
@@ -377,14 +377,15 @@ async function copyToClipboard(text) {
 import fs4 from "fs/promises";
 import path4 from "path";
 async function writeEvent(options) {
-  const { workspacePath, step, type, summary, workItemId, links } = options;
+  const { workspacePath, step, type, summary, workItemId, links, data } = options;
   const event = {
     ts: (/* @__PURE__ */ new Date()).toISOString(),
     step,
     type,
     summary,
     ...workItemId && { workItemId },
-    ...links && links.length > 0 && { links }
+    ...links && links.length > 0 && { links },
+    ...data && { data }
   };
   try {
     const eventsPath = path4.join(workspacePath, "events.jsonl");
@@ -571,7 +572,7 @@ async function validateArtifactFile(filePath) {
   try {
     const content = await fs5.readFile(filePath, "utf-8");
     return validateArtifact(content);
-  } catch (error) {
+  } catch {
     return {
       valid: false,
       errors: [
@@ -799,7 +800,8 @@ function getDefaultSummary(eventType, stepId) {
     "accept.passed": "\u9A8C\u6536\u901A\u8FC7",
     "accept.failed": "\u9A8C\u6536\u5931\u8D25",
     "issue.raised": "\u53D1\u73B0\u95EE\u9898",
-    "handoff.sent": "\u5DF2\u4EA4\u63A5\u7ED9\u4E0B\u4E00\u6B65"
+    "handoff.sent": "\u5DF2\u4EA4\u63A5\u7ED9\u4E0B\u4E00\u6B65",
+    "automation.session": "\u81EA\u52A8\u5316\u4F1A\u8BDD\u5DF2\u8BB0\u5F55"
   };
   return summaries[eventType] || `\u4E8B\u4EF6: ${eventType}`;
 }
@@ -818,6 +820,14 @@ var DEFAULT_CONFIG = {
     logStepStarted: true,
     logStepDone: true
   },
+  automation: {
+    enabled: false,
+    provider: "nutjs",
+    screenshot: false,
+    timeout: 3e4,
+    retries: 3,
+    confidence: 0.8
+  },
   clipboard: {
     autoCopy: false
   },
@@ -989,7 +999,7 @@ var configCommand = new Command6("config").description("\u67E5\u770B\u6216\u7BA1
     } else if (action === "init") {
       await initConfig(options);
     } else if (action === "list") {
-      await listConfig(options);
+      await listConfig();
     } else {
       console.error(`Unknown action: ${action}`);
       console.log("Available actions: show, init, list");
@@ -1023,7 +1033,7 @@ async function initConfig(options) {
   console.log("Default configuration:");
   console.log(JSON.stringify(DEFAULT_CONFIG, null, 2));
 }
-async function listConfig(options) {
+async function listConfig() {
   console.log("Configuration options:");
   console.log("");
   console.log("  defaultWorkspace     - \u9ED8\u8BA4 workspace \u8DEF\u5F84");
@@ -1044,10 +1054,733 @@ async function listConfig(options) {
   console.log(`  ~/.agenthandoffrc (global)`);
 }
 
+// src/cli/commands/report.ts
+import { Command as Command7 } from "commander";
+import fs9 from "fs/promises";
+import path10 from "path";
+
+// src/adapters/trae/operation-reporter.ts
+import fs8 from "fs/promises";
+var OperationReporter = class {
+  session;
+  constructor(session) {
+    this.session = session;
+  }
+  generate(options) {
+    switch (options.format) {
+      case "json":
+        return this.generateJson();
+      case "markdown":
+        return this.generateMarkdown(options.includeScreenshots);
+      case "html":
+        return this.generateHtml(options.includeScreenshots);
+      default:
+        return this.generateMarkdown(options.includeScreenshots);
+    }
+  }
+  generateJson() {
+    return JSON.stringify(this.session, null, 2);
+  }
+  generateMarkdown(includeScreenshots) {
+    const lines = [
+      "# Automation Session Report",
+      "",
+      `**Session ID:** ${this.session.id}`,
+      `**Started At:** ${this.session.startedAt}`,
+      `**Workspace:** ${this.session.workspacePath}`,
+      `**Step ID:** ${this.session.stepId}`,
+      ...this.session.status ? [`**Status:** ${this.session.status}`] : [],
+      ...this.session.error ? [`**Error:** ${this.session.error}`] : [],
+      "",
+      `## Operations (${this.session.operations.length})`,
+      ""
+    ];
+    this.session.operations.forEach((op, index) => {
+      lines.push(`### ${index + 1}. ${op.type}`);
+      if (op.target) {
+        lines.push(`- **Target:** ${op.target}`);
+      }
+      if (op.value) {
+        lines.push(
+          `- **Value:** ${op.value.substring(0, 100)}${op.value.length > 100 ? "..." : ""}`
+        );
+      }
+      lines.push(`- **Timestamp:** ${new Date(op.timestamp).toISOString()}`);
+      lines.push("");
+    });
+    if (includeScreenshots && this.session.screenshots.length > 0) {
+      lines.push(`## Screenshots (${this.session.screenshots.length})`);
+      lines.push("");
+      this.session.screenshots.forEach((screenshot, index) => {
+        lines.push(`### Screenshot ${index + 1}`);
+        lines.push(`![Screenshot ${index + 1}](${screenshot})`);
+        lines.push("");
+      });
+    }
+    return lines.join("\n");
+  }
+  generateHtml(includeScreenshots) {
+    const operationsHtml = this.session.operations.map(
+      (op, index) => `
+      <div class="operation">
+        <h3>${index + 1}. ${op.type}</h3>
+        ${op.target ? `<p><strong>Target:</strong> ${op.target}</p>` : ""}
+        ${op.value ? `<p><strong>Value:</strong> ${op.value.substring(0, 100)}${op.value.length > 100 ? "..." : ""}</p>` : ""}
+        <p><strong>Timestamp:</strong> ${new Date(op.timestamp).toISOString()}</p>
+      </div>
+    `
+    ).join("");
+    const screenshotsHtml = includeScreenshots && this.session.screenshots.length > 0 ? `
+        <h2>Screenshots (${this.session.screenshots.length})</h2>
+        ${this.session.screenshots.map(
+      (s, i) => `
+          <div class="screenshot">
+            <h3>Screenshot ${i + 1}</h3>
+            <img src="${s}" alt="Screenshot ${i + 1}" />
+          </div>
+        `
+    ).join("")}
+      ` : "";
+    const statusLine = this.session.status ? `<p><strong>Status:</strong> ${this.session.status}</p>` : "";
+    const errorLine = this.session.error ? `<p><strong>Error:</strong> ${this.session.error}</p>` : "";
+    return `
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Automation Session Report</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 800px;
+      margin: 0 auto;
+      padding: 20px;
+      background: #f5f5f5;
+    }
+    .header {
+      background: white;
+      padding: 20px;
+      border-radius: 8px;
+      margin-bottom: 20px;
+    }
+    .operation {
+      background: white;
+      padding: 15px;
+      border-radius: 8px;
+      margin-bottom: 10px;
+    }
+    .screenshot img {
+      max-width: 100%;
+      border-radius: 8px;
+    }
+    h1 { color: #333; }
+    h2 { color: #555; border-bottom: 1px solid #eee; padding-bottom: 10px; }
+    h3 { color: #666; margin: 0 0 10px 0; }
+    p { margin: 5px 0; color: #666; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>Automation Session Report</h1>
+    <p><strong>Session ID:</strong> ${this.session.id}</p>
+    <p><strong>Started At:</strong> ${this.session.startedAt}</p>
+    <p><strong>Workspace:</strong> ${this.session.workspacePath}</p>
+    <p><strong>Step ID:</strong> ${this.session.stepId}</p>
+    ${statusLine}
+    ${errorLine}
+  </div>
+
+  <h2>Operations (${this.session.operations.length})</h2>
+  ${operationsHtml}
+
+  ${screenshotsHtml}
+</body>
+</html>
+    `.trim();
+  }
+  async saveToFile(outputPath, options) {
+    const content = this.generate(options);
+    await fs8.writeFile(outputPath, content, "utf-8");
+    return outputPath;
+  }
+};
+
+// src/cli/commands/report.ts
+var reportCommand = new Command7("report").description("\u751F\u6210\u81EA\u52A8\u5316\u64CD\u4F5C\u62A5\u544A").argument("[workspace]", "workspace \u8DEF\u5F84", ".").option("-f, --format <format>", "\u62A5\u544A\u683C\u5F0F: json, markdown, html", "markdown").option("-s, --session <id>", "\u6307\u5B9A session ID").option("--screenshots", "\u5305\u542B\u622A\u56FE", false).option("-o, --output <path>", "\u8F93\u51FA\u8DEF\u5F84").action(
+  async (workspace, options) => {
+    const workspacePath = path10.resolve(workspace);
+    const logDir = path10.join(workspacePath, "operations");
+    try {
+      let sessionFile;
+      if (options.session) {
+        sessionFile = path10.join(logDir, `operations-${options.session}.jsonl`);
+      } else {
+        const files = await fs9.readdir(logDir);
+        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl")).sort().reverse();
+        if (jsonlFiles.length === 0) {
+          console.error("Error: no operation logs found");
+          process.exit(1);
+        }
+        sessionFile = path10.join(logDir, jsonlFiles[0]);
+      }
+      const content = await fs9.readFile(sessionFile, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      const session = JSON.parse(lines[lines.length - 1]);
+      const reporter = new OperationReporter(session);
+      const report = reporter.generate({
+        format: options.format,
+        includeScreenshots: options.screenshots
+      });
+      if (options.output) {
+        await fs9.writeFile(path10.resolve(options.output), report, "utf-8");
+        console.log(`\u2705 Report saved to: ${options.output}`);
+      } else {
+        console.log(report);
+      }
+    } catch (error) {
+      console.error(`Error: ${error}`);
+      process.exit(1);
+    }
+  }
+);
+
+// src/cli/commands/export.ts
+import { Command as Command8 } from "commander";
+import path13 from "path";
+
+// src/export/web/exporter.ts
+import fs11 from "fs/promises";
+import path12 from "path";
+
+// src/core/events-reader.ts
+import fs10 from "fs/promises";
+import path11 from "path";
+async function readEventsJsonl(options) {
+  const eventsPath = path11.join(options.workspacePath, "events.jsonl");
+  try {
+    const content = await fs10.readFile(eventsPath, "utf-8");
+    const lines = content.split("\n").filter((line) => line.trim());
+    const events = [];
+    let invalidLines = 0;
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        events.push(event);
+      } catch {
+        invalidLines += 1;
+      }
+    }
+    events.sort((a, b) => {
+      const ats = a.ts ?? "";
+      const bts = b.ts ?? "";
+      if (ats < bts) return -1;
+      if (ats > bts) return 1;
+      return 0;
+    });
+    const limited = typeof options.limit === "number" && options.limit > 0 ? events.slice(-options.limit) : events;
+    return { events: limited, invalidLines };
+  } catch {
+    return { events: [], invalidLines: 0 };
+  }
+}
+function toTimelineItems(events) {
+  return events.map((event) => ({
+    ts: event.ts,
+    stepId: event.step.id,
+    stepIndex: event.step.index,
+    type: event.type,
+    summary: event.summary,
+    ...event.workItemId && { workItemId: event.workItemId },
+    ...event.links && event.links.length > 0 && { links: event.links },
+    ...event.data && { data: event.data }
+  }));
+}
+
+// src/export/web/artifact-indexer.ts
+import crypto from "crypto";
+function sanitizeSegments(segments) {
+  const result = [];
+  for (const seg of segments) {
+    const trimmed = seg.trim();
+    if (!trimmed || trimmed === ".") continue;
+    if (trimmed === "..") {
+      result.push("__");
+      continue;
+    }
+    result.push(trimmed);
+  }
+  return result;
+}
+function toSafeFilename(original) {
+  const rawSegments = original.split(/[\\/]+/g);
+  const safeSegments = sanitizeSegments(rawSegments);
+  const base = safeSegments.join("-") || "artifact";
+  const normalized = base.replace(/[^a-zA-Z0-9._-]+/g, "_");
+  const suffix = ".html";
+  const maxLen = 180;
+  if (normalized.length + suffix.length <= maxLen) {
+    return normalized + suffix;
+  }
+  const hash = crypto.createHash("sha1").update(original).digest("hex").slice(0, 10);
+  const headLen = Math.max(16, maxLen - suffix.length - 1 - hash.length);
+  const head = normalized.slice(0, headLen);
+  return `${head}-${hash}${suffix}`;
+}
+function buildArtifactLinkMap(links) {
+  const seen = /* @__PURE__ */ new Set();
+  const mappings = [];
+  for (const link of links) {
+    const original = String(link);
+    if (seen.has(original)) continue;
+    seen.add(original);
+    const filename = toSafeFilename(original);
+    const outputHtmlPath = `artifacts/${filename}`;
+    mappings.push({ original, outputHtmlPath, title: original });
+  }
+  return mappings;
+}
+
+// src/export/web/artifact-renderer.ts
+function escapeHtml(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function renderArtifactPage(options) {
+  const title = escapeHtml(options.title);
+  const originalPath = escapeHtml(options.originalPath);
+  const content = escapeHtml(options.content);
+  return [
+    "<!doctype html>",
+    '<html lang="zh-CN">',
+    "<head>",
+    '<meta charset="utf-8" />',
+    '<meta name="viewport" content="width=device-width, initial-scale=1" />',
+    `<title>${title}</title>`,
+    "<style>",
+    'body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial; color: #111827; background: #ffffff; }',
+    ".container { max-width: 1040px; margin: 0 auto; padding: 24px; }",
+    "h1 { font-size: 18px; margin: 0 0 8px; }",
+    '.path { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; font-size: 12px; color: #374151; }',
+    "pre { margin-top: 16px; background: #0b1020; color: #e5e7eb; padding: 12px; border-radius: 10px; overflow: auto; font-size: 12px; line-height: 1.5; }",
+    "</style>",
+    "</head>",
+    "<body>",
+    '<div class="container">',
+    `<h1>${title}</h1>`,
+    `<div class="path">${originalPath}</div>`,
+    `<pre>${content}</pre>`,
+    "</div>",
+    "</body>",
+    "</html>",
+    ""
+  ].join("\n");
+}
+
+// src/export/web/timeline-renderer.ts
+function escapeHtml2(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function renderLinks(links, linkHrefMap) {
+  const items = links.map((link) => {
+    const href = linkHrefMap && linkHrefMap[link] ? linkHrefMap[link] : link;
+    const safeLabel = escapeHtml2(link);
+    const safeHref = escapeHtml2(href);
+    return `<a href="${safeHref}" data-link="${safeLabel}" target="_blank" rel="noopener noreferrer">${safeLabel}</a>`;
+  }).join("");
+  return `<div class="links">${items}</div>`;
+}
+function renderData(data) {
+  const json = escapeHtml2(JSON.stringify(data, null, 2));
+  return `<details><summary>data</summary><pre>${json}</pre></details>`;
+}
+function renderWebTimeline(options) {
+  const assets = {};
+  if (options.includeAssets) {
+    assets["assets/viewer.css"] = getDefaultCss();
+    assets["assets/viewer.js"] = getDefaultJs();
+  }
+  const title = escapeHtml2(options.title);
+  const workspaceName = escapeHtml2(options.workspaceName);
+  const generatedAt = escapeHtml2(options.generatedAt);
+  const eventsJson = escapeHtml2(JSON.stringify(options.items));
+  const linkMapJson = escapeHtml2(JSON.stringify(options.linkHrefMap || {}));
+  const headAssets = options.includeAssets ? `<link rel="stylesheet" href="assets/viewer.css" />` : "";
+  const bodyAssets = options.includeAssets ? `<script src="assets/viewer.js"></script>` : "";
+  const list = options.items.map((item) => {
+    const ts = escapeHtml2(item.ts);
+    const stepId = escapeHtml2(item.stepId);
+    const type = escapeHtml2(item.type);
+    const summary = escapeHtml2(item.summary);
+    const workItem = item.workItemId ? `<span class="badge">${escapeHtml2(item.workItemId)}</span>` : "";
+    const links = item.links && item.links.length > 0 ? renderLinks(item.links, options.linkHrefMap) : "";
+    const data = item.data ? renderData(item.data) : "";
+    return [
+      `<div class="item" data-step="${stepId}" data-type="${type}">`,
+      `<div class="row">`,
+      `<span class="ts">${ts}</span>`,
+      `<span class="badge">${stepId}</span>`,
+      `<span class="type">${type}</span>`,
+      workItem,
+      `</div>`,
+      `<div class="summary">${summary}</div>`,
+      links,
+      data,
+      `</div>`
+    ].join("");
+  }).join("");
+  const html = [
+    "<!doctype html>",
+    '<html lang="zh-CN">',
+    "<head>",
+    '<meta charset="utf-8" />',
+    '<meta name="viewport" content="width=device-width, initial-scale=1" />',
+    `<title>${title}</title>`,
+    headAssets,
+    "</head>",
+    "<body>",
+    '<div class="container">',
+    "<header>",
+    `<h1>${workspaceName} Timeline</h1>`,
+    `<div class="meta">Generated at ${generatedAt}</div>`,
+    "</header>",
+    '<section class="filters" id="timeline-filters">',
+    '<div class="filters-row">',
+    '<input id="filter-q" type="search" placeholder="\u641C\u7D22 summary / data..." />',
+    '<select id="filter-step"></select>',
+    '<select id="filter-type"></select>',
+    '<select id="filter-workItem"></select>',
+    '<button id="filter-clear" type="button">\u6E05\u7A7A\u7B5B\u9009</button>',
+    "</div>",
+    '<div class="filters-meta" id="filters-meta"></div>',
+    "</section>",
+    `<script id="__EVENTS__" type="application/json">${eventsJson}</script>`,
+    `<script id="__LINK_HREF_MAP__" type="application/json">${linkMapJson}</script>`,
+    `<div class="list" id="timeline-list">${list}</div>`,
+    "</div>",
+    bodyAssets,
+    "</body>",
+    "</html>"
+  ].filter((x) => x !== "").join("\n");
+  return { html, assets };
+}
+function getDefaultCss() {
+  return [
+    "* { box-sizing: border-box; }",
+    'body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, "Apple Color Emoji", "Segoe UI Emoji"; color: #111827; background: #ffffff; }',
+    ".container { max-width: 1040px; margin: 0 auto; padding: 24px; }",
+    "header { display: flex; align-items: baseline; justify-content: space-between; gap: 16px; border-bottom: 1px solid #e5e7eb; padding-bottom: 12px; margin-bottom: 16px; }",
+    "h1 { font-size: 20px; margin: 0; }",
+    ".meta { font-size: 12px; color: #6b7280; }",
+    ".filters { margin: 12px 0 16px; padding: 12px; border: 1px solid #e5e7eb; border-radius: 10px; background: #fafafa; }",
+    ".filters-row { display: grid; grid-template-columns: 1.4fr 1fr 1fr 1fr auto; gap: 10px; align-items: center; }",
+    ".filters-row input, .filters-row select { width: 100%; padding: 8px 10px; border-radius: 8px; border: 1px solid #d1d5db; font-size: 13px; background: #fff; }",
+    ".filters-row button { padding: 8px 12px; border-radius: 8px; border: 1px solid #d1d5db; background: #fff; cursor: pointer; }",
+    ".filters-row button:hover { background: #f3f4f6; }",
+    ".filters-meta { margin-top: 8px; font-size: 12px; color: #6b7280; }",
+    ".list { display: flex; flex-direction: column; gap: 10px; }",
+    ".item { border: 1px solid #e5e7eb; border-radius: 10px; padding: 12px; }",
+    ".row { display: flex; flex-wrap: wrap; gap: 8px 12px; align-items: center; }",
+    '.ts { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; font-size: 12px; color: #374151; }',
+    ".badge { display: inline-flex; align-items: center; padding: 2px 8px; border-radius: 999px; font-size: 12px; background: #eff6ff; color: #1d4ed8; border: 1px solid #dbeafe; }",
+    '.type { font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace; font-size: 12px; color: #111827; background: #f3f4f6; padding: 2px 8px; border-radius: 8px; }',
+    ".summary { margin-top: 8px; white-space: pre-wrap; line-height: 1.45; }",
+    ".links { margin-top: 10px; display: flex; flex-wrap: wrap; gap: 8px; }",
+    ".links a { font-size: 12px; color: #2563eb; text-decoration: none; border-bottom: 1px dashed #93c5fd; }",
+    ".links a:hover { border-bottom-style: solid; }",
+    "details { margin-top: 10px; }",
+    "pre { background: #0b1020; color: #e5e7eb; padding: 10px; border-radius: 10px; overflow: auto; font-size: 12px; line-height: 1.5; }",
+    ""
+  ].join("\n");
+}
+function getDefaultJs() {
+  return [
+    "(() => {",
+    "  const g = globalThis;",
+    "  const doc = g.document;",
+    '  if (!doc || typeof doc.getElementById !== "function") return;',
+    '  const el = doc.getElementById("__EVENTS__");',
+    "  if (!el) return;",
+    '  const qInput = doc.getElementById("filter-q");',
+    '  const stepSelect = doc.getElementById("filter-step");',
+    '  const typeSelect = doc.getElementById("filter-type");',
+    '  const workItemSelect = doc.getElementById("filter-workItem");',
+    '  const clearBtn = doc.getElementById("filter-clear");',
+    '  const listEl = doc.getElementById("timeline-list");',
+    '  const metaEl = doc.getElementById("filters-meta");',
+    "  const HTMLInput = g.HTMLInputElement;",
+    "  const HTMLSelect = g.HTMLSelectElement;",
+    "  const HTMLButton = g.HTMLButtonElement;",
+    "  const HTMLElementCtor = g.HTMLElement;",
+    "  if (!HTMLInput || !HTMLSelect || !HTMLButton || !HTMLElementCtor) return;",
+    "  if (",
+    "    !(qInput instanceof HTMLInput) ||",
+    "    !(stepSelect instanceof HTMLSelect) ||",
+    "    !(typeSelect instanceof HTMLSelect) ||",
+    "    !(workItemSelect instanceof HTMLSelect) ||",
+    "    !(clearBtn instanceof HTMLButton) ||",
+    "    !(listEl instanceof HTMLElementCtor)",
+    "  ) {",
+    "    return;",
+    "  }",
+    "  let events;",
+    "  try {",
+    '    events = JSON.parse(el.textContent || "[]");',
+    "  } catch {",
+    "    return;",
+    "  }",
+    '  const linkMapEl = doc.getElementById("__LINK_HREF_MAP__");',
+    "  let linkHrefMap = {};",
+    '  if (linkMapEl && typeof linkMapEl.textContent === "string" && linkMapEl.textContent.trim()) {',
+    "    try {",
+    "      linkHrefMap = JSON.parse(linkMapEl.textContent) || {};",
+    "    } catch {",
+    "      linkHrefMap = {};",
+    "    }",
+    "  }",
+    '  const safeText = (v) => (v == null ? "" : String(v));',
+    "  const normalize = (v) => safeText(v).toLowerCase();",
+    "  const getUniqueSorted = (arr) =>",
+    '    Array.from(new Set(arr.filter((x) => x != null && String(x).trim() !== "").map(String))).sort();',
+    "  const steps = getUniqueSorted(events.map((e) => e.stepId));",
+    "  const types = getUniqueSorted(events.map((e) => e.type));",
+    "  const workItems = getUniqueSorted(events.map((e) => e.workItemId));",
+    "  const setOptions = (select, values, labelAll) => {",
+    '    select.innerHTML = "";',
+    '    const optAll = doc.createElement("option");',
+    '    optAll.value = "";',
+    "    optAll.textContent = labelAll;",
+    "    select.appendChild(optAll);",
+    "    for (const v of values) {",
+    '      const opt = doc.createElement("option");',
+    "      opt.value = v;",
+    "      opt.textContent = v;",
+    "      select.appendChild(opt);",
+    "    }",
+    "  };",
+    '  setOptions(stepSelect, steps, "\u5168\u90E8 step");',
+    '  setOptions(typeSelect, types, "\u5168\u90E8 type");',
+    '  setOptions(workItemSelect, workItems, "\u5168\u90E8 workItem");',
+    '  const getQuery = () => new URLSearchParams(g.location ? g.location.search : "");',
+    "  const applyFromUrl = () => {",
+    "    const qs = getQuery();",
+    '    qInput.value = safeText(qs.get("q") || "");',
+    '    stepSelect.value = safeText(qs.get("step") || "");',
+    '    typeSelect.value = safeText(qs.get("type") || "");',
+    '    workItemSelect.value = safeText(qs.get("workItem") || "");',
+    "  };",
+    "  const writeUrl = () => {",
+    "    if (!g.history || !g.location) return;",
+    "    const qs = new URLSearchParams();",
+    '    if (qInput.value.trim()) qs.set("q", qInput.value.trim());',
+    '    if (stepSelect.value) qs.set("step", stepSelect.value);',
+    '    if (typeSelect.value) qs.set("type", typeSelect.value);',
+    '    if (workItemSelect.value) qs.set("workItem", workItemSelect.value);',
+    "    const qsStr = qs.toString();",
+    "    const next = qsStr ? `${g.location.pathname}?${qsStr}` : g.location.pathname;",
+    '    g.history.replaceState(null, "", next);',
+    "  };",
+    "  const escapeHtml = (input) =>",
+    "    safeText(input)",
+    '      .replaceAll("&", "&amp;")',
+    '      .replaceAll("<", "&lt;")',
+    '      .replaceAll(">", "&gt;")',
+    '      .replaceAll("\\"", "&quot;")',
+    `      .replaceAll("\\'", "&#39;");`,
+    "  const renderLinks = (links) => {",
+    '    if (!Array.isArray(links) || links.length === 0) return "";',
+    "    const html = links",
+    "      .map((l) => {",
+    "        const href = linkHrefMap && linkHrefMap[l] ? linkHrefMap[l] : l;",
+    "        const safeHref = escapeHtml(href);",
+    "        const label = escapeHtml(l);",
+    '        return `<a href="${safeHref}" target="_blank" rel="noopener noreferrer">${label}</a>`;',
+    "      })",
+    '      .join("");',
+    '    return `<div class="links">${html}</div>`;',
+    "  };",
+    "  const renderData = (data) => {",
+    '    if (!data) return "";',
+    '    let json = "";',
+    "    try {",
+    "      json = JSON.stringify(data, null, 2);",
+    "    } catch {",
+    "      json = safeText(data);",
+    "    }",
+    "    return `<details><summary>data</summary><pre>${escapeHtml(json)}</pre></details>`;",
+    "  };",
+    "  const renderList = (items) => {",
+    "    listEl.innerHTML = items",
+    "      .map((item) => {",
+    "        const ts = escapeHtml(item.ts);",
+    "        const stepId = escapeHtml(item.stepId);",
+    "        const type = escapeHtml(item.type);",
+    "        const summary = escapeHtml(item.summary);",
+    '        const workItem = item.workItemId ? `<span class="badge">${escapeHtml(item.workItemId)}</span>` : "";',
+    "        return [",
+    '          `<div class="item" data-step="${stepId}" data-type="${type}">`,',
+    '          `<div class="row">`,',
+    '          `<span class="ts">${ts}</span>`,',
+    '          `<span class="badge">${stepId}</span>`,',
+    '          `<span class="type">${type}</span>`,',
+    "          workItem,",
+    "          `</div>`,",
+    '          `<div class="summary">${summary}</div>`,',
+    "          renderLinks(item.links),",
+    "          renderData(item.data),",
+    "          `</div>`,",
+    '        ].join("");',
+    "      })",
+    '      .join("");',
+    "  };",
+    "  const applyFilters = () => {",
+    "    const q = normalize(qInput.value.trim());",
+    "    const step = safeText(stepSelect.value);",
+    "    const type = safeText(typeSelect.value);",
+    "    const workItem = safeText(workItemSelect.value);",
+    "    const filtered = events.filter((e) => {",
+    "      if (step && safeText(e.stepId) !== step) return false;",
+    "      if (type && safeText(e.type) !== type) return false;",
+    "      if (workItem && safeText(e.workItemId) !== workItem) return false;",
+    "      if (!q) return true;",
+    "      const hay1 = normalize(e.summary);",
+    '      let hay2 = "";',
+    "      try {",
+    "        hay2 = normalize(JSON.stringify(e.data || {}));",
+    "      } catch {",
+    '        hay2 = normalize(String(e.data || ""));',
+    "      }",
+    "      return hay1.includes(q) || hay2.includes(q);",
+    "    });",
+    "    renderList(filtered);",
+    "    if (metaEl) {",
+    "      metaEl.textContent = `\u663E\u793A ${filtered.length} / ${events.length}`;",
+    "    }",
+    "    writeUrl();",
+    "  };",
+    "  applyFromUrl();",
+    "  applyFilters();",
+    '  qInput.addEventListener("input", applyFilters);',
+    '  stepSelect.addEventListener("change", applyFilters);',
+    '  typeSelect.addEventListener("change", applyFilters);',
+    '  workItemSelect.addEventListener("change", applyFilters);',
+    '  clearBtn.addEventListener("click", () => {',
+    '    qInput.value = "";',
+    '    stepSelect.value = "";',
+    '    typeSelect.value = "";',
+    '    workItemSelect.value = "";',
+    "    applyFilters();",
+    "  });",
+    "})();",
+    ""
+  ].join("\n");
+}
+
+// src/export/web/exporter.ts
+async function ensureDir(dir) {
+  await fs11.mkdir(dir, { recursive: true });
+}
+async function exportWebTimeline(options) {
+  const { events, invalidLines } = await readEventsJsonl({
+    workspacePath: options.workspacePath,
+    limit: options.limit
+  });
+  const items = toTimelineItems(events);
+  const linkSet = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    for (const link of item.links || []) {
+      linkSet.add(link);
+    }
+  }
+  const mappings = buildArtifactLinkMap([...linkSet]);
+  const linkHrefMap = {};
+  for (const m of mappings) {
+    linkHrefMap[m.original] = m.outputHtmlPath;
+  }
+  const out = path12.resolve(options.outputDir);
+  await ensureDir(out);
+  await ensureDir(path12.join(out, "assets"));
+  await ensureDir(path12.join(out, "artifacts"));
+  for (const m of mappings) {
+    const artifactSourcePath = path12.join(options.workspacePath, m.original);
+    let content;
+    try {
+      content = await fs11.readFile(artifactSourcePath, "utf-8");
+    } catch {
+      content = `\u6587\u4EF6\u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u8BFB\u53D6: ${m.original}`;
+    }
+    const html = renderArtifactPage({
+      title: m.title,
+      originalPath: m.original,
+      content
+    });
+    const fullOutPath = path12.join(out, m.outputHtmlPath);
+    await ensureDir(path12.dirname(fullOutPath));
+    await fs11.writeFile(fullOutPath, html, "utf-8");
+  }
+  const timeline = renderWebTimeline({
+    title: "AgentHandoff Timeline",
+    workspaceName: path12.basename(path12.resolve(options.workspacePath)),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    items,
+    includeAssets: true,
+    linkHrefMap
+  });
+  await fs11.writeFile(path12.join(out, "index.html"), timeline.html, "utf-8");
+  for (const [rel, content] of Object.entries(timeline.assets)) {
+    const full = path12.join(out, rel);
+    await ensureDir(path12.dirname(full));
+    await fs11.writeFile(full, content, "utf-8");
+  }
+  return {
+    outputDir: out,
+    indexPath: path12.join(out, "index.html"),
+    eventsCount: items.length,
+    invalidLines,
+    artifactsCount: mappings.length
+  };
+}
+
+// src/cli/commands/export.ts
+var exportCommand = new Command8("export").description("\u5BFC\u51FA\u9759\u6001\u4EA7\u7269\uFF08\u4F8B\u5982 Web Timeline\uFF09").argument("[workspace]", "workspace \u8DEF\u5F84", ".").requiredOption("--format <format>", "\u5BFC\u51FA\u683C\u5F0F: web", "web").option("-o, --output <dir>", "\u5BFC\u51FA\u76EE\u5F55\uFF08\u9ED8\u8BA4 <workspace>/timeline\uFF09").option("--limit <n>", "\u53EA\u5BFC\u51FA\u6700\u8FD1 n \u6761\u4E8B\u4EF6", (v) => parseInt(v, 10)).action(
+  async (workspace, options) => {
+    const workspacePath = path13.resolve(workspace);
+    try {
+      const info = await loadWorkspace(workspacePath);
+      if (!info.exists) {
+        console.error(`Error: workspace not found: ${workspacePath}`);
+        process.exit(1);
+      }
+      if (!info.hasWorkflow) {
+        console.error(`Error: workflow.yaml not found in ${workspacePath}`);
+        process.exit(1);
+      }
+      if (options.format !== "web") {
+        console.error(`Error: unsupported format: ${options.format}`);
+        process.exit(1);
+      }
+      const outputDir = options.output ? path13.resolve(options.output) : path13.join(workspacePath, "timeline");
+      const result = await exportWebTimeline({
+        workspacePath,
+        outputDir,
+        limit: options.limit
+      });
+      console.log(`\u2705 Exported to: ${result.outputDir}`);
+      console.log(`  index: ${result.indexPath}`);
+      console.log(`  events: ${result.eventsCount} (invalid lines: ${result.invalidLines})`);
+      console.log(`  artifacts: ${result.artifactsCount}`);
+      console.log("");
+      console.log(`\u6253\u5F00\u65B9\u5F0F\uFF08macOS\uFF09\uFF1Aopen ${path13.join(result.outputDir, "index.html")}`);
+    } catch (error) {
+      console.error(`Error: ${error}`);
+      process.exit(1);
+    }
+  }
+);
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command7();
+var program = new Command9();
 program.name("agent-handoff").description("\u8F7B\u91CF\u7EA7\u591A Agent \u534F\u4F5C\u63A5\u529B\u5DE5\u5177").version(version);
 program.addCommand(initCommand);
 program.addCommand(statusCommand);
@@ -1055,5 +1788,7 @@ program.addCommand(nextCommand);
 program.addCommand(validateCommand);
 program.addCommand(advanceCommand);
 program.addCommand(configCommand);
+program.addCommand(reportCommand);
+program.addCommand(exportCommand);
 program.parse();
 //# sourceMappingURL=index.js.map