autocrew 0.3.10 → 0.4.1

package/src/cli/commands/render.ts

@@ -0,0 +1,78 @@
+import type { CommandDef } from "./index.js";
+import { getOption } from "./index.js";
+
+export const cmd: CommandDef = {
+  name: "render",
+  description: "Render a video timeline (TTS + screenshots + Jianying export)",
+  usage: "autocrew render <project-slug> [--voice <voiceId>] [--ratio <9:16|16:9>]",
+  action: async (args, runner) => {
+    const slug = args[0];
+    if (!slug) {
+      console.error("Usage: autocrew render <project-slug> [--voice <voiceId>] [--ratio <9:16|16:9>]");
+      process.exitCode = 1;
+      return;
+    }
+
+    const voice = getOption(args, "--voice") || "default";
+    const ratio = getOption(args, "--ratio") || "9:16";
+
+    // Find project and its timeline
+    try {
+      const { findProject } = await import("../../storage/pipeline-store.js");
+      const path = await import("node:path");
+      const fs = await import("node:fs/promises");
+
+      const found = await findProject(slug);
+      if (!found) {
+        console.error(`Project not found: "${slug}"`);
+        process.exitCode = 1;
+        return;
+      }
+
+      const timelinePath = path.join(found.dir, "timeline.json");
+      let timeline;
+      try {
+        const raw = await fs.readFile(timelinePath, "utf-8");
+        timeline = JSON.parse(raw);
+      } catch {
+        console.error(`No timeline.json found in project "${slug}".`);
+        console.error("Generate a timeline first with autocrew_timeline action='generate'.");
+        process.exitCode = 1;
+        return;
+      }
+
+      // Try to load studio
+      let renderTimeline: any;
+      let loadConfig: any;
+      try {
+        const studio = await import("autocrew-studio");
+        renderTimeline = studio.renderTimeline;
+        loadConfig = studio.loadConfig;
+      } catch {
+        console.error("autocrew-studio is not installed. Install it with:");
+        console.error("  npm install autocrew-studio");
+        process.exitCode = 1;
+        return;
+      }
+
+      const config = loadConfig();
+      const outputDir = path.join(found.dir, "render");
+
+      console.log(`Rendering timeline for "${slug}" (${ratio}, voice: ${voice})...`);
+
+      const result = await renderTimeline({
+        timeline,
+        outputDir,
+        tts: config.tts,
+        screenshot: config.screenshot,
+        exporter: config.exporter,
+        voice: { voiceId: voice },
+      });
+
+      console.log(`Render complete: ${result.path} (${result.format})`);
+    } catch (err: any) {
+      console.error(`Render failed: ${err.message || err}`);
+      process.exitCode = 1;
+    }
+  },
+};

package/src/e2e.test.ts

@@ -198,16 +198,13 @@ describe("E2E: Draft Action (content generation)", () => {
     // Should return creator context
     expect(result.creatorContext).toBeDefined();
 
-    // Should return writing instructions with Operating System principles
+    // Should return writing instructions with thinking-oriented prompts
     const instructions = result.writingInstructions as string;
-    expect(instructions).toContain("EMPATHY FIRST");
-    expect(instructions).toContain("THEIR WORDS, NOT YOURS");
-    expect(instructions).toContain("SHOW THE MOVIE");
-    expect(instructions).toContain("TENSION IS OXYGEN");
-    expect(instructions).toContain("THE CREATOR IS THE PROOF");
-    expect(instructions).toContain("TWO-PHASE CREATION");
-    expect(instructions).toContain("PHASE A");
-    expect(instructions).toContain("PHASE B");
+    expect(instructions).toContain("Writing Instructions");
+    expect(instructions).toContain("WHO is reading this");
+    expect(instructions).toContain("ONE opinion");
+    expect(instructions).toContain("skeleton FIRST");
+    expect(instructions).toContain("autocrew_content");
 
     // Should return next action guidance
     expect((result.nextAction as any).tool).toBe("autocrew_content");

package/src/modules/workflow/templates.ts

@@ -12,6 +12,17 @@ const TEMPLATES: WorkflowDefinition[] = [
     id: "xiaohongshu_full",
     name: "小红书一键发布",
     description: "从选题调研到发布的完整小红书内容流水线。包含 AI 写作、去 AI 痕迹、敏感词审查、封面设计等全流程。",
+    restatement: {
+      intervalSteps: 3,
+      context: [
+        "## Restatement — 质量提醒",
+        "- 标题必须 ≤20 中文字符",
+        "- 风格必须符合 STYLE.md",
+        "- 每段必须制造或解决张力，不能只是罗列信息",
+        "- 保持创作者第一人称视角",
+        "- 不要使用 AI 套话：值得一提的是、综上所述、首先其次最后",
+      ].join("\n"),
+    },
     steps: [
       {
         id: "research",
@@ -70,6 +81,15 @@ const TEMPLATES: WorkflowDefinition[] = [
     id: "quick_publish",
     name: "快速发布",
     description: "已有内容的快速发布流程。去 AI 痕迹 → 审查 → 平台适配 → 封面 → 发布。",
+    restatement: {
+      intervalSteps: 3,
+      context: [
+        "## Restatement — 质量提醒",
+        "- 风格必须符合 STYLE.md",
+        "- 不要使用 AI 套话",
+        "- 发布前确保封面和内容匹配",
+      ].join("\n"),
+    },
     steps: [
       {
         id: "humanize",

package/src/runtime/context.ts

@@ -7,6 +7,7 @@
  * - Audit trail for debugging
  */
 import path from "node:path";
+import type { SessionLogger } from "./logger.js";
 
 // --- Types ---
 
@@ -51,6 +52,8 @@ export interface ToolContext {
   workspace: WorkspaceState;
   /** Audit log for this session */
   audit: AuditEntry[];
+  /** Persistent session logger (writes to ~/.autocrew/logs/) */
+  logger?: SessionLogger;
 }
 
 // --- Factory ---
@@ -70,13 +73,14 @@ function resolveDataDir(config?: PluginConfig): string {
 /**
  * Create a new ToolContext. Called once per plugin registration or MCP session.
  */
-export function createContext(config?: PluginConfig): ToolContext {
+export function createContext(config?: PluginConfig, logger?: SessionLogger): ToolContext {
   const ctx: ToolContext = {
     sessionId: generateSessionId(),
     dataDir: resolveDataDir(config),
     config: config || {},
     workspace: {},
     audit: [],
+    logger,
   };
   _activeContext = ctx;
   return ctx;

package/src/runtime/logger.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { SessionLogger } from "./logger.js";
+
+describe("SessionLogger", () => {
+  let tmpDir: string;
+  let logger: SessionLogger;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "autocrew-log-"));
+    logger = new SessionLogger(tmpDir, "test-session-001");
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it("writes audit entries as JSONL", async () => {
+    await logger.audit({
+      tool: "autocrew_content",
+      action: "save",
+      timestamp: "2026-04-09T10:00:00Z",
+      durationMs: 150,
+      ok: true,
+    });
+
+    const logPath = path.join(tmpDir, "logs", "test-session-001", "audit.jsonl");
+    const raw = await fs.readFile(logPath, "utf-8");
+    const lines = raw.trim().split("\n");
+    expect(lines).toHaveLength(1);
+    expect(JSON.parse(lines[0]).tool).toBe("autocrew_content");
+  });
+
+  it("writes events as JSONL", async () => {
+    await logger.event({
+      type: "content:created",
+      timestamp: "2026-04-09T10:00:00Z",
+      data: { contentId: "abc" },
+    });
+
+    const logPath = path.join(tmpDir, "logs", "test-session-001", "events.jsonl");
+    const raw = await fs.readFile(logPath, "utf-8");
+    const lines = raw.trim().split("\n");
+    expect(lines).toHaveLength(1);
+    expect(JSON.parse(lines[0]).type).toBe("content:created");
+  });
+
+  it("writes tool IO as JSONL", async () => {
+    await logger.toolIO({
+      tool: "autocrew_content",
+      action: "draft",
+      input: { topic_title: "AI编程", platform: "xhs" },
+      output: { ok: true, writingInstructions: "..." },
+      durationMs: 200,
+      timestamp: "2026-04-09T10:00:00Z",
+    });
+
+    const logPath = path.join(tmpDir, "logs", "test-session-001", "tool-io.jsonl");
+    const raw = await fs.readFile(logPath, "utf-8");
+    const entry = JSON.parse(raw.trim());
+    expect(entry.tool).toBe("autocrew_content");
+    expect(entry.input.topic_title).toBe("AI编程");
+    expect(entry.output.ok).toBe(true);
+  });
+
+  it("appends multiple entries without overwriting", async () => {
+    await logger.audit({ tool: "a", timestamp: "t1", durationMs: 1, ok: true });
+    await logger.audit({ tool: "b", timestamp: "t2", durationMs: 2, ok: false, error: "boom" });
+
+    const logPath = path.join(tmpDir, "logs", "test-session-001", "audit.jsonl");
+    const lines = (await fs.readFile(logPath, "utf-8")).trim().split("\n");
+    expect(lines).toHaveLength(2);
+  });
+});

package/src/runtime/logger.ts

@@ -0,0 +1,84 @@
+/**
+ * SessionLogger — persistent JSONL logging for audit entries, events, and tool IO.
+ *
+ * Writes to {dataDir}/logs/{sessionId}/ with separate files:
+ * - audit.jsonl   — tool execution audit trail
+ * - events.jsonl  — workflow events
+ * - tool-io.jsonl — full tool input/output for debugging
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { AuditEntry } from "./context.js";
+import type { AutoCrewEvent } from "./events.js";
+
+export interface ToolIOEntry {
+  tool: string;
+  action?: string;
+  input: Record<string, unknown>;
+  output: Record<string, unknown>;
+  durationMs: number;
+  timestamp: string;
+}
+
+export class SessionLogger {
+  private sessionDir: string;
+  private initialized = false;
+
+  constructor(dataDir: string, sessionId: string) {
+    this.sessionDir = path.join(dataDir, "logs", sessionId);
+  }
+
+  private async ensureDir(): Promise<void> {
+    if (!this.initialized) {
+      await fs.mkdir(this.sessionDir, { recursive: true });
+      this.initialized = true;
+    }
+  }
+
+  private async append(filename: string, data: unknown): Promise<void> {
+    await this.ensureDir();
+    const line = JSON.stringify(data) + "\n";
+    await fs.appendFile(path.join(this.sessionDir, filename), line, "utf-8");
+  }
+
+  async audit(entry: AuditEntry): Promise<void> {
+    await this.append("audit.jsonl", entry);
+  }
+
+  async event(event: AutoCrewEvent): Promise<void> {
+    await this.append("events.jsonl", event);
+  }
+
+  async toolIO(entry: ToolIOEntry): Promise<void> {
+    await this.append("tool-io.jsonl", entry);
+  }
+}
+
+/** List all session log directories, newest first */
+export async function listLogSessions(dataDir: string): Promise<string[]> {
+  const logsDir = path.join(dataDir, "logs");
+  try {
+    const entries = await fs.readdir(logsDir);
+    return entries.sort().reverse();
+  } catch {
+    return [];
+  }
+}
+
+/** Delete session logs older than N days */
+export async function cleanOldLogs(dataDir: string, maxAgeDays: number): Promise<number> {
+  const logsDir = path.join(dataDir, "logs");
+  const cutoff = Date.now() - maxAgeDays * 86400000;
+  let deleted = 0;
+  try {
+    const entries = await fs.readdir(logsDir);
+    for (const entry of entries) {
+      const stat = await fs.stat(path.join(logsDir, entry));
+      if (stat.mtimeMs < cutoff) {
+        await fs.rm(path.join(logsDir, entry), { recursive: true });
+        deleted++;
+      }
+    }
+  } catch { /* logs dir may not exist */ }
+  return deleted;
+}

package/src/runtime/tool-runner.ts

@@ -172,6 +172,39 @@ const auditMiddleware: Middleware = async (ctx, toolName, params, next) => {
   return result;
 };
 
+/** Persist tool IO to disk via SessionLogger */
+const persistentLogMiddleware: Middleware = async (ctx, toolName, params, next) => {
+  const start = Date.now();
+  const { _dataDir, _gatewayUrl, _geminiApiKey, _geminiModel, ...loggedInput } = params;
+  let result: ToolResult;
+  try {
+    result = await next();
+  } catch (err) {
+    if (ctx.logger) {
+      await ctx.logger.toolIO({
+        tool: toolName,
+        action: loggedInput.action as string | undefined,
+        input: loggedInput,
+        output: { ok: false, error: err instanceof Error ? err.message : String(err) },
+        durationMs: Date.now() - start,
+        timestamp: new Date().toISOString(),
+      });
+    }
+    throw err;
+  }
+  if (ctx.logger) {
+    await ctx.logger.toolIO({
+      tool: toolName,
+      action: loggedInput.action as string | undefined,
+      input: loggedInput,
+      output: result,
+      durationMs: Date.now() - start,
+      timestamp: new Date().toISOString(),
+    });
+  }
+  return result;
+};
+
 /** Update workspace state based on tool results */
 const workspaceTrackingMiddleware: Middleware = async (ctx, toolName, params, next) => {
   const result = await next();
@@ -206,6 +239,7 @@ export class ToolRunner {
       onboardingGateMiddleware,
       errorBoundaryMiddleware,
       auditMiddleware,
+      persistentLogMiddleware,
       workspaceTrackingMiddleware,
       ...(options.middleware || []),
     ];

package/src/runtime/workflow-engine.test.ts

@@ -452,4 +452,73 @@ describe("WorkflowEngine", () => {
   it("throws when starting a nonexistent workflow", async () => {
     await expect(engine.start("nonexistent")).rejects.toThrow("not found");
   });
+
+  describe("restatement", () => {
+    it("injects restatement context every N steps", async () => {
+      runner.register({
+        name: "echo_tool",
+        label: "Echo",
+        description: "always succeeds",
+        parameters: {},
+        execute: vi.fn(async () => ({ ok: true, value: "done" })),
+      });
+
+      const def: WorkflowDefinition = {
+        id: "restate-test",
+        name: "Restatement Test",
+        description: "Tests restatement injection",
+        steps: Array.from({ length: 6 }, (_, i) => ({
+          id: `step-${i}`,
+          name: `Step ${i}`,
+          tool: "echo_tool",
+          params: {},
+        })),
+        restatement: {
+          intervalSteps: 3,
+          context: "IMPORTANT: Follow quality rules.",
+        },
+      };
+
+      engine.registerDefinition(def);
+      const instance = await engine.create("restate-test");
+      const result = await engine.start(instance.id);
+
+      expect(result.status).toBe("completed");
+      // After step index 3 (steps 0,1,2 done), restatement should fire
+      expect(result.stepResults["_restatement_after_step-2"]).toBeDefined();
+      expect((result.stepResults["_restatement_after_step-2"] as any).context).toBe("IMPORTANT: Follow quality rules.");
+      // After step index 6 (steps 3,4,5 done), another restatement
+      expect(result.stepResults["_restatement_after_step-5"]).toBeDefined();
+    });
+
+    it("does not inject restatement when not configured", async () => {
+      runner.register({
+        name: "echo_tool2",
+        label: "Echo2",
+        description: "always succeeds",
+        parameters: {},
+        execute: vi.fn(async () => ({ ok: true, value: "done" })),
+      });
+
+      const def: WorkflowDefinition = {
+        id: "no-restate",
+        name: "No Restatement",
+        description: "No restatement configured",
+        steps: Array.from({ length: 4 }, (_, i) => ({
+          id: `s-${i}`,
+          name: `Step ${i}`,
+          tool: "echo_tool2",
+          params: {},
+        })),
+      };
+
+      engine.registerDefinition(def);
+      const instance = await engine.create("no-restate");
+      const result = await engine.start(instance.id);
+
+      expect(result.status).toBe("completed");
+      const restateKeys = Object.keys(result.stepResults).filter(k => k.startsWith("_restatement_"));
+      expect(restateKeys).toHaveLength(0);
+    });
+  });
 });

package/src/runtime/workflow-engine.ts

@@ -35,6 +35,13 @@ export interface WorkflowDefinition {
   name: string;
   description: string;
   steps: WorkflowStep[];
+  /** Optional: inject restatement context every N steps to combat attention decay */
+  restatement?: {
+    /** Inject restatement every N steps */
+    intervalSteps: number;
+    /** The context string to restate (key rules, current goal, quality constraints) */
+    context: string;
+  };
 }
 
 export type WorkflowStatus = "pending" | "running" | "paused" | "completed" | "failed" | "cancelled";
@@ -350,6 +357,19 @@ export class WorkflowEngine {
 
       // Advance
       instance.currentStepIndex++;
+
+      // Restatement injection — combat attention decay in long workflows
+      if (def.restatement && instance.currentStepIndex > 0 && instance.currentStepIndex % def.restatement.intervalSteps === 0) {
+        const restateKey = `_restatement_after_${step.id}`;
+        instance.stepResults[restateKey] = {
+          type: "restatement",
+          context: def.restatement.context,
+          afterStep: step.id,
+          stepIndex: instance.currentStepIndex,
+          timestamp: new Date().toISOString(),
+        };
+      }
+
       await this.persistInstance(instance);
     }
 

package/src/tools/content-save.ts

@@ -149,39 +149,21 @@ Clock Theory: Bang moments at 12:00(hook), 3:00(escalation), 6:00(payload), 9:00
     methodology,
     wikiContext: wikiContext || "(no wiki knowledge available yet)",
     writingInstructions: `
-You are now writing a content draft for Chinese social media. Follow these instructions EXACTLY.
+## Writing Instructions
 
-## THE OPERATING SYSTEM — 5 Principles (override everything else)
+Think through these questions before writing:
 
-1. EMPATHY FIRST — You are sitting across from ONE person (the audiencePersona). They are scrolling, half-distracted. Every sentence must earn their next 3 seconds. If a sentence triggers no curiosity, recognition, surprise, or relief — delete it.
+1. WHO is reading this? (Reference the audiencePersona above)
+2. WHAT is the ONE opinion this content argues? (Not a topic — an opinion)
+3. WHY would a reader stop scrolling for this? (The hook)
+4. WHAT evidence makes this believable? (Creator's own experience > external data)
 
-2. THEIR WORDS, NOT YOURS — Every word must pass: would the reader say this to a friend over coffee? If no, replace it. No jargon, no abstractions, no "smart" words the reader wouldn't use.
+Then:
+- Build a skeleton FIRST (thesis → evidence → twist → action). Present it for confirmation.
+- Write the full draft only after skeleton is confirmed.
+- Every paragraph must either open a question or close one. No "information-only" paragraphs.
 
-3. SHOW THE MOVIE — Abstractions are invisible. Stories are visible. Every claim needs a scene: a face, a number, a moment. "She built a product in 3 weeks, alone" > "AI improves efficiency."
-
-4. TENSION IS OXYGEN — Every paragraph must either OPEN a question or CLOSE one. No paragraph should just "sit there" as information. When energy drops, inject a question, contradiction, or surprise.
-
-5. THE CREATOR IS THE PROOF — The creator's own experience is the strongest evidence. Lead with "I did X" before "Company Y did Z." Vulnerability > authority.
-
-## TWO-PHASE CREATION
-
-PHASE A — Build the skeleton FIRST (do not write prose yet):
-- A1: Core thesis in ONE sentence (an opinion, not a topic)
-- A2: Argument structure (thesis → evidence → twist → action)
-- A3: Clock Theory — plan 4 bang moments (12:00 hook, 3:00 escalation, 6:00 payload, 9:00 climax)
-- A4: HKRR — choose dominant dimension
-- A5: Place 2-3 micro-retention techniques
-
-Present the skeleton to the user. Wait for confirmation. Then:
-
-PHASE B — Write the full draft based on the skeleton.
-- Fear short, not long. Every case study deserves full detail.
-- After each clock section, simulate the reader's reaction.
-- Ground every factual claim in real sources.
-
-## AFTER WRITING
-
-Call autocrew_content action="save" with the full body text, title, platform, and hypothesis.
+Save via autocrew_content action="save" with title, body, platform, and hypothesis.
 Do NOT use the Write tool to create draft.md directly.
 `,
     nextAction: {

package/templates/AGENTS.md

@@ -14,50 +14,9 @@
 10. After completing a task, suggest one concrete next step.
 11. When user gives feedback on content, capture it via the memory-distill skill.
 
-## Onboarding Protocol (MANDATORY — cannot be skipped)
+## Onboarding Protocol
 
-This is the FIRST thing that happens for any new user. No exceptions.
-
-### Gate Check
-1. Call `autocrew_pro_status` at session start.
-2. If ANY of these are true → BLOCK all other actions and run onboarding:
-   - `profileExists: false`
-   - `missingInfo` array is non-empty
-   - `styleCalibrated: false`
-
-### Onboarding Flow (3 phases, must complete all)
-
-**Phase 1: 初始化 + 基础信息（2-3 轮对话）**
-1. Call `autocrew_init` to create data directory
-2. Read host MEMORY.md if it exists (extract known info)
-3. Ask for missing fields ONLY:
-   - 行业/领域（必填）
-   - 目标平台（必填，可多选：小红书/抖音/公众号/视频号）
-   - 目标受众（必填：年龄段、职业、痛点）
-   - 变现模式（选填：广告/带货/知识付费/引流）
-4. Save to creator-profile.json
-
-**Phase 2: 风格校准（3-5 轮对话）**
-1. 询问用户是否有参考账号或已有内容样本
-2. 如果有 → 分析样本，提取风格特征
-3. 如果没有 → 通过 A/B 对比问题确定风格偏好：
-   - 正式 vs 口语
-   - 专业术语 vs 大白话
-   - 长文深度 vs 短文快节奏
-   - 情感共鸣 vs 干货实用
-4. 生成 STYLE.md 写作人格文件
-5. 更新 creator-profile.json 的 `styleCalibrated: true`
-
-**Phase 3: 确认 + 过渡**
-1. 展示生成的风格档案摘要
-2. 告诉用户"设置完成，现在可以开始创作了"
-3. 然后继续用户的原始请求（如果有的话）
-
-### 重要：不要把 onboarding 做成审讯
-- 语气轻松友好，像朋友聊天
-- 每次最多问 2-3 个问题
-- 已知信息（从 MEMORY.md 读到的）直接确认，不重复问
-- 风格校准用选择题，不要让用户写长文
+Onboarding is enforced by the tool system. If a tool returns `error: "onboarding_required"`, `error: "profile_incomplete"`, or `error: "style_not_calibrated"`, follow the returned instructions to complete setup before proceeding. Keep the tone conversational — like chatting with a friend, not an interrogation.
 
 ## Memory Protocol
 
@@ -74,26 +33,13 @@ This is the FIRST thing that happens for any new user. No exceptions.
 
 ## Skill Routing
 
-| User intent | Skill to load |
-|-------------|---------------|
+| User intent | Skill |
+|-------------|-------|
 | First use / profile incomplete | onboarding |
-| /setup / "设置" / "风格校准" / "品牌校准" / "calibrate" | setup |
-| "帮我找选题" / "调研" / "这周写什么" / "内容规划" | spawn-planner or research (must also load title-craft for title methodology) |
-| "帮我想" / "想选题" / seed idea | topic-ideas (must also load title-craft for title methodology) |
-| "受众分析" / "用户画像" / "audience" | audience-profiler |
-| "二创" / "换个角度写" / "remix" | remix-content |
-| "写这个" / "帮我写" / "写一篇" | spawn-writer |
-| "批量写" / "都写了" / "写N篇" | spawn-batch-writer |
-| "改写" / "适配" / "发到XX平台" | platform-rewrite |
-| "去AI味" / "润色" | humanizer-zh |
-| "审核" / "检查" / "敏感词" | content-review |
-| "封面" / "生成封面" / "做个封面" | cover-generator |
-| "发布前检查" | pre-publish |
-| "发布" / "发到小红书" | publish-content |
-| "自动化" / "定时" / "pipeline" | manage-pipeline |
+| "设置" / "风格校准" / "calibrate" | setup |
+| "帮我写" / "写一篇" / "写这个" | spawn-writer (loads write-script + title-craft) |
+| "批量写" / "都写了" | spawn-batch-writer |
+| "帮我找选题" / "调研" / "内容规划" | spawn-planner or research (loads title-craft) |
 | User gives feedback on content | memory-distill |
-| "状态" / "进度" | autocrew_status tool |
-| "对标" / "监控" / competitor URL | [Pro] competitor-monitor |
-| Video/note URL + "分析/拆解" | [Pro] video-analysis |
-| Video/note URL (no analysis intent) | [Pro] extract-video-script |
-| "数据" / "分析报告" | [Pro] analytics-report |
+
+For other intents (封面, 发布, 审核, 去AI味, 改写, 状态, 对标, 数据), use the corresponding autocrew_* tool directly — the tool names are self-explanatory.