Harness 解剖：构建一个能运行数小时的编码 Agent

export const askUserTool = createTool({
  id: 'askUser',
  description: 'Ask the user a question and wait for their response. ...',
  inputSchema: z.object({ /* question, options, selectionMode */ }),
  execute: async ({ question, options, selectionMode }, context) => {
    const harnessCtx = context?.requestContext?.get('harness') as HarnessRequestContext | undefined;

    // 没有 harness 回调？降级为纯文本，而不是阻塞。
    if (!harnessCtx?.emitEvent || !harnessCtx?.registerQuestion) {
      return { content: `[Question for user]: ${question}`, isError: false };
    }

    const questionId = `q_${++questionCounter}_${Date.now()}`;

    const answer = await new Promise<HarnessQuestionAnswer>((resolve, reject) => {
      const signal = harnessCtx.abortSignal;
      // ... 把 `signal` 接到 reject()，这样 Ctrl-C 能干净地取消等待 ...
      harnessCtx.registerQuestion!({ questionId, resolve });                          // 暂存一个 resolver
      harnessCtx.emitEvent!({ type: 'askQuestion', questionId, question, options }); // 绘制提示框
    });

    return { content: `User answered: ${formatQuestionAnswer(answer)}`, isError: false };
  },
});

export const submitPlanTool = createTool({
  id: 'submitPlan',
  description: 'Submit a completed implementation plan for user review. ... On approval, the system automatically switches to the default mode so you can implement.',
  inputSchema: z.object({ /* title, plan (markdown) */ }),
  execute: async ({ title, plan }, context) => {
    const harnessCtx = context?.requestContext?.get('harness') as HarnessRequestContext | undefined;

    // 与 askUser 相同的纯文本回退：未挂接 harness 时使用。
    if (!harnessCtx?.emitEvent || !harnessCtx?.registerPlanApproval) {
      return { content: `[Plan submitted for review]\n\nTitle: ${title || 'Implementation Plan'}\n\n${plan}`, isError: false };
    }

    const planId = `plan_${++planCounter}_${Date.now()}`;

    const result = await new Promise<{ action: 'approved' | 'rejected'; feedback?: string }>((resolve, reject) => {
      const signal = harnessCtx.abortSignal;
      // ... 把 `signal` 接到 reject()，这样 Ctrl-C 能干净地取消等待 ...
      harnessCtx.registerPlanApproval!({ planId, resolve });                          // 暂存一个 resolver
      harnessCtx.emitEvent!({ type: 'planApprovalRequired', planId, title, plan }); // 渲染计划
    });

    if (result.action === 'approved') {
      return { content: 'Plan approved. Proceed with implementation following the approved plan.', isError: false };
    }
    // 被拒绝：把反馈交回给模型，以便修改后重新提交。
    const feedback = result.feedback ? `\n\nUser feedback: ${result.feedback}` : '';
    return { content: `Plan was not approved. The user wants revisions.${feedback}`, isError: false };
  },
});

export function assignTaskIds(tasks: TaskItemInput[], previousTasks: TaskItemSnapshot[] = []): TaskItemSnapshot[] {
  const usedIds = new Set<string>();
  const contentOccurrences = new Map<string, number>();
  const omittedContentCounts = new Map<string, number>();
  const explicitTaskIds = new Set(tasks.map(task => task.id).filter((id): id is string => Boolean(id)));
  const reusablePreviousIds = new Map<number, string>();
  for (const task of tasks) {
    if (!task.id) {
      omittedContentCounts.set(task.content, (omittedContentCounts.get(task.content) ?? 0) + 1);
    }
  }
  tasks.forEach((task, index) => {
    if (task.id || omittedContentCounts.get(task.content) !== 1) return;
    const previousMatches = previousTasks.filter(
      previous => previous.content === task.content && !explicitTaskIds.has(previous.id),
    );
    if (previousMatches.length === 1) {
      reusablePreviousIds.set(index, previousMatches[0]!.id);
    }
  });

  const reservedIds = new Set([...explicitTaskIds, ...reusablePreviousIds.values()]);
  return tasks.map((task, index) => {
    const contentOccurrence = (contentOccurrences.get(task.content) ?? 0) + 1;
    contentOccurrences.set(task.content, contentOccurrence);

    const fallbackId = createDeterministicTaskId(task, contentOccurrence);
    const reusablePreviousId = reusablePreviousIds.get(index);
    // 如果模型在同一次写入中重复使用显式 ID，保留第一个
    // 并为重复项生成/复用稳定的回退 ID，而不是让整个列表失败。
    const requestedId = task.id && !usedIds.has(task.id) ? task.id : undefined;
    const id =
      requestedId ??
      (reusablePreviousId && !usedIds.has(reusablePreviousId)
        ? reusablePreviousId
        : makeUniqueTaskId(fallbackId, usedIds, reservedIds));
    usedIds.add(id);
    return {
      id,
      content: task.content,
      status: task.status,
      activeForm: task.activeForm,
    };
  });
}

private resolveToolApproval(toolName: string): PermissionPolicy {
  const state = this.state as Record<string, unknown>;
  const rules = this.getPermissionRules();
  const toolPolicy = rules.tools[toolName];
  if (toolPolicy === 'deny') return 'deny';        // 1. 按工具拒绝，硬性拦截
  if (state.yolo === true) return 'allow';         // 2. YOLO 自动批准上述未被拒绝的一切
  if (toolPolicy) return toolPolicy;               // 3. 显式的按工具 allow/ask
  if (this.sessionGrantedTools.has(toolName)) return 'allow'; // 4. 会话级工具授权
  const category = this.getToolCategory({ toolName });
  if (category) {
    if (this.sessionGrantedCategories.has(category)) return 'allow'; // 5. 会话级类别授权
    const categoryPolicy = rules.categories[category];
    if (categoryPolicy) return categoryPolicy;     // 6. 显式的按类别 allow/ask
  }
  return 'ask';                                    // 7. 默认 ask
}