#Plan 06 — studio-api Migration Implementation Plan

// apps/api/src/lib/check-silent-reject.ts
import type { ApplyResult } from '@retaintive/common/domain';
import { ConflictError, NotFoundError } from '../errors';  // 用 studio-api 现有 error types
import { logger } from '../logger';

interface CheckOpts {
  /** record_progress 的 idempotency_key duplicate 是预期 retry,只 log 不 throw */
  allowDuplicate?: boolean;
}

/**
 * 校验 sql.transaction() 返回的每个 statement result row count,
 * 跟 ApplyResult.resultChecks 比对。0 row = silent business reject。
 *
 * pattern source: normative-spec.md §3.1 line 251 contract
 */
export function checkSilentReject(
  resultChecks: ApplyResult['resultChecks'] | undefined,
  txResults: unknown[],  // neon-http sql.transaction 返回 row arrays
  ctx: { taskId: string; userId: string },
  action: 'close' | 'reopen' | 'postpone' | 'record_progress',
  opts: CheckOpts = {},
): void {
  for (const check of resultChecks ?? []) {
    const stmtResult = txResults[check.statementIndex];
    const rowCount = Array.isArray(stmtResult) ? stmtResult.length : 0;
    if (rowCount === 0) {
      logger.warn(`${action} silent reject — 0 rows`, {
        ...ctx,
        reason: check.zeroRowsReason,
      });
      if (opts.allowDuplicate && check.zeroRowsReason === 'duplicate') {
        continue;  // record_progress retry,预期幂等
      }
      // throw map per zeroRowsReason
      throw makeErrorFor(check.zeroRowsReason, action);
    }
  }
}

function makeErrorFor(reason: string | undefined, action: string): Error {
  switch (reason) {
    case 'task_not_open':
      return new ConflictError(`Task is not open (cannot ${action})`);
    case 'task_not_closed':
      return new ConflictError(`Task is not closed (cannot ${action})`);
    case 'stale_proposal':
      return new ConflictError('Stale request — please refresh and try again');
    case 'duplicate':
      return new ConflictError('Duplicate request');
    default:
      return new ConflictError(`Operation rejected: ${reason ?? 'unknown'}`);
  }
}

// apps/api/src/__tests__/routes/tasks-close.test.ts
import { describe, it, expect, beforeEach } from 'vitest';
import { testApp, seedTask, seedContact, getTaskRow } from '../helpers/test-app.ts';

describe('PATCH /v2/tasks/close', () => {
  beforeEach(async () => { await resetTestDb(); });

  it('closes open task atomically (UPDATE + timeline in same transaction)', async () => {
    const { taskId, contactPhone, storeId } = await seedTask({ status: 'open', typeCategory: 'lead_follow_up' });
    const res = await testApp.request(`/v2/tasks/close?taskId=${taskId}`, {
      method: 'PATCH',
      body: JSON.stringify({ storeId, staffName: 'Alice', closeResult: 'converted', note: '' }),
      headers: { 'Content-Type': 'application/json' },
    });
    expect(res.status).toBe(200);
    const updated = await getTaskRow(taskId);
    expect(updated.status).toBe('closed');
    // Verify timeline row written
    const timeline = await getTimelineRows(taskId);
    expect(timeline).toHaveLength(1);
    expect(timeline[0].event_type).toBe('task.status_changed');
  });

  it('rejects close with progress closeResult — routes user to progress endpoint', async () => {
    const { taskId, storeId } = await seedTask({ status: 'open' });
    const res = await testApp.request(`/v2/tasks/close?taskId=${taskId}`, {
      method: 'PATCH',
      body: JSON.stringify({ storeId, staffName: 'Alice', closeResult: 'no_answer', note: '' }),
      headers: { 'Content-Type': 'application/json' },
    });
    expect(res.status).toBe(400);
    const body = await res.json();
    expect(body.error).toMatch(/progress endpoint/i);
  });

  it('uses one sql.transaction for UPDATE + timeline (B2 wrapper)', async () => {
    const { taskId, contactPhone, storeId } = await seedTask({ status: 'open' });
    const sqlSpy = vi.spyOn(getNeonClient(), 'transaction');
    const res = await testApp.request(`/v2/tasks/close?taskId=${taskId}`, {
      method: 'PATCH',
      body: JSON.stringify({ storeId, staffName: 'Alice', closeResult: 'converted', note: '' }),
      headers: { 'Content-Type': 'application/json' },
    });
    expect(res.status).toBe(200);
    expect(sqlSpy).toHaveBeenCalledTimes(1);
    expect(sqlSpy.mock.calls[0]![0]).toHaveLength(1); // Orchestrator returns complete SQL unit(s)
    sqlSpy.mockRestore();
  });
});

// apps/api/src/routes/tasks/close.ts
import { Hono } from 'hono';
import { z } from 'zod';
import { buildTaskActionSQL } from '@retaintive/common/domain';
import { getNeonClient } from '../../services/neon.ts';
import { getAuthorizedStoreNeon } from '../../utils/store-authorization-neon.ts';
import { logger } from '../../utils/logger.ts';
import {
  ValidationError, NotFoundError, ForbiddenError, ConflictError,
} from '../../utils/errors.ts';
import type { CloseTaskResult } from './types.ts';

const PROGRESS_CLOSE_RESULTS = new Set([
  'no_answer', 'left_voicemail', 'callback_later', 'attempted',
]);

const querySchema = z.object({ taskId: z.string().uuid() });
const bodySchema = z.object({
  storeId: z.string().min(1),
  staffName: z.string().min(1).max(200),
  closeResult: z.string().min(1).max(100),
  note: z.string().max(1000).optional().default(''),
});

export const closeTaskRoute = new Hono()
  .patch('/close', async (c) => {
    const auth = c.get('auth');
    const userId = auth.userId;

    const queryParsed = querySchema.safeParse(c.req.query());
    if (!queryParsed.success) throw new ValidationError(queryParsed.error.message);
    const { taskId } = queryParsed.data;

    const body = await c.req.json();
    const bodyParsed = bodySchema.safeParse(body);
    if (!bodyParsed.success) throw new ValidationError(bodyParsed.error.message);
    const { storeId, staffName, closeResult, note } = bodyParsed.data;

    /*
     * Phase 1: close API does NOT accept progress closeResult values.
     * Frontend (Phase 1.5) should call POST /v2/tasks/:taskId/progress instead.
     * Temporary fallback until UI ships — return 400 with a helpful message.
     */
    if (PROGRESS_CLOSE_RESULTS.has(closeResult)) {
      throw new ValidationError(
        `closeResult='${closeResult}' is a progress event, not a close outcome. ` +
        `Use POST /v2/tasks/${taskId}/progress instead.`,
      );
    }

    const storeAuth = await getAuthorizedStoreNeon(userId, storeId);
    if (storeAuth.status === 'not_found') throw new NotFoundError('Store');
    if (storeAuth.status === 'forbidden') throw new ForbiddenError('No access to this store');
    if (storeAuth.role === 'VIEWER') throw new ForbiddenError('Viewers cannot modify tasks');

    const sql = getNeonClient();

    /*
     * Phase 1: route delegates to @retaintive/common/domain buildTaskActionSQL.
     * It handles Policy Guard (hallucination / state / DNC-allowed-for-close /
     * closeNote required) and returns transactional statements (UPDATE + timeline).
     */
    const result = await buildTaskActionSQL(
      {
        action: 'close',
        payload: { taskId, closeResult: closeResult as any, closeNote: note },
      },
      {
        storeId,
        actor: { type: 'staff', id: userId, name: staffName },
        db: sql as any,  // adapter accepts NeonHttpClient internally for SELECTs
      } as any,
    );

    if (result.status === 'reject') {
      switch (result.reason) {
        case 'hallucinated_task_id':
          throw new NotFoundError('Task');
        case 'task_not_open':
          throw new ConflictError('Task is already closed');
        case 'close_note_required':
          throw new ValidationError('closeNote required when closeResult=other');
        case 'stale_proposal':
          throw new ConflictError('Task was modified by another actor');
        case 'invalid_close_result':
          throw new ValidationError(`invalid closeResult: ${result.details}`);
        case 'store_mismatch':
          throw new NotFoundError('Task');  // 不泄露跨 store 存在
        default:
          throw new ValidationError(result.details ?? `rejected: ${result.reason}`);
      }
    }

    /*
     * B2 — sql.transaction wraps all statements (UPDATE + timeline INSERT)
     * into a single Postgres BEGIN/COMMIT. NEVER replace with a for-loop
     * of sql.query() — that is non-atomic and breaks audit consistency.
     *
     * neon-http sql.transaction 返回 each statement 的 result rows array,
     * 我们用它 + result.resultChecks 检测 silent business reject(spec §3.1
     * line 251):0-row RETURNING = stale_proposal / task_not_open / 等。
     */
    const txResults = await sql.transaction(result.statements.map(stmt => sql(stmt.sql, stmt.params)));

    for (const check of result.resultChecks ?? []) {
      const stmtResult = txResults[check.statementIndex];
      const rowCount = Array.isArray(stmtResult) ? stmtResult.length : 0;
      if (rowCount === 0) {
        // 0 rows = business invariant violated(stale snapshot / wrong state)。
        // close endpoint 这里翻译成 409 Conflict — 前端 staff 手动 close
        // 时碰到 race 才会触发(AI close 已在 Lambda path,不走 studio-api)。
        logger.warn('Close silent reject — 0 rows', {
          taskId, userId, reason: check.zeroRowsReason,
        });
        throw new ConflictError(
          check.zeroRowsReason === 'task_not_open'
            ? 'Task is already closed by another user'
            : 'Stale request — please refresh and try again',
        );
      }
    }

    logger.info('Task closed', { taskId, staffName, closeResult, userId });

    return c.json({
      data: {
        task_id: taskId,
        status: 'closed' as const,
        closed_at: new Date().toISOString(),
      } satisfies CloseTaskResult,
    });
  });

// apps/api/src/routes/tasks/reopen.ts (核心改动 — 省略 import / Zod schema)
const result = await buildTaskActionSQL(
  { action: 'reopen', payload: { taskId } },
  {
    storeId,
    actor: { type: 'staff', id: userId },
    db: sql as any,
  } as any,
);

if (result.status === 'reject') {
  switch (result.reason) {
    case 'hallucinated_task_id': throw new NotFoundError('Task');
    case 'task_not_closed': throw new ConflictError('Task is already open');
    case 'dnc': throw new ValidationError('Cannot reopen task for DNC contact');
    case 'store_mismatch': throw new NotFoundError('Task');
    default: throw new ValidationError(result.details ?? `rejected: ${result.reason}`);
  }
}

// B2 — sql.transaction wrap + resultChecks(spec §3.1 line 251)
const txResults = await sql.transaction(result.statements.map(stmt => sql(stmt.sql, stmt.params)));
checkSilentReject(result.resultChecks, txResults, { taskId, userId }, 'reopen');

return c.json({
  data: {
    task_id: taskId,
    status: 'open' as const,
    updated_at: new Date().toISOString(),
  } satisfies ReopenTaskResult,
});

// apps/api/src/routes/tasks/postpone.ts (核心改动)
// 保留现有 route-level dueAt future check
if (newDueAt.getTime() <= Date.now()) {
  throw new ValidationError('dueAt must be in the future');
}

const result = await buildTaskActionSQL(
  {
    action: 'update',
    payload: { taskId, dueAt: newDueAt },  // 只改 dueAt
  },
  {
    storeId,
    actor: { type: 'staff', id: userId },
    db: sql as any,
  } as any,
);

if (result.status === 'reject') {
  switch (result.reason) {
    case 'hallucinated_task_id': throw new NotFoundError('Task');
    case 'task_not_open': throw new ConflictError('Cannot postpone a closed task');
    case 'dnc': throw new ValidationError('Cannot postpone task for DNC contact');
    case 'store_mismatch': throw new NotFoundError('Task');
    default: throw new ValidationError(result.details ?? `rejected: ${result.reason}`);
  }
}

// B2 — sql.transaction wrap + resultChecks(spec §3.1 line 251)
const txResults = await sql.transaction(result.statements.map(stmt => sql(stmt.sql, stmt.params)));
checkSilentReject(result.resultChecks, txResults, { taskId, userId }, 'postpone');

return c.json({
  data: {
    task_id: taskId,
    due_at: newDueAt.toISOString(),
    updated_at: new Date().toISOString(),
  },
});

// apps/api/src/routes/tasks/progress.ts (NEW FILE)
/**
 * POST /v2/tasks/:taskId/progress — Record progress event
 *
 * Records a non-terminal touch on an open task. Examples: no_answer,
 * left_voicemail, text_sent, callback_requested, follow_up_scheduled,
 * customer_considering.
 *
 * Phase 1 ship: 这是新端点,替代过去通过 close API + closeResult ∈ progress_set
 * 触发的"关旧建新 follow-up"模式。现在 progress 单独追踪,task 保持 open,
 * attempt_count 累加,dueAt 按 progressType 自动推后。
 *
 * Data: writes to task_progress_events + UPDATE tasks (attempt_count + due_at)
 *       + contact_timeline (task.progress_recorded)
 *       全部在单个 sql.transaction() 内原子提交 (B2)
 */
import { Hono } from 'hono';
import { z } from 'zod';
import { buildTaskActionSQL } from '@retaintive/common/domain';
import { getNeonClient } from '../../services/neon.ts';
import { getAuthorizedStoreNeon } from '../../utils/store-authorization-neon.ts';
import { logger } from '../../utils/logger.ts';
import {
  ValidationError, NotFoundError, ForbiddenError, ConflictError,
} from '../../utils/errors.ts';

const PROGRESS_TYPES = [
  'no_answer', 'left_voicemail', 'text_sent',
  'callback_requested', 'follow_up_scheduled', 'customer_considering',
] as const;
const CHANNELS = ['phone', 'sms', 'voicemail', 'email'] as const;

// progressType 需要 nextDueAt — Orchestrator 内部 computeNextDueAt 对这两类返回
// currentDueAt 不变;route-level 提示用户必传 override 避免 dueAt 不动 = bug
const REQUIRES_NEXT_DUE_AT = new Set([
  'callback_requested', 'follow_up_scheduled',
]);

const querySchema = z.object({ taskId: z.string().uuid() });
const bodySchema = z.object({
  storeId: z.string().min(1),
  progressType: z.enum(PROGRESS_TYPES),
  channel: z.enum(CHANNELS),
  callId: z.string().optional(),
  messageId: z.string().optional(),
  note: z.string().max(1000).optional(),
  nextDueAt: z.string().datetime().optional(),
}).refine(
  (b) => !REQUIRES_NEXT_DUE_AT.has(b.progressType) || !!b.nextDueAt,
  { message: 'nextDueAt is required for callback_requested / follow_up_scheduled' },
);

export const progressRoute = new Hono()
  .post('/:taskId/progress', async (c) => {
    const auth = c.get('auth');
    const userId = auth.userId;
    const staffName = auth.staffName ?? auth.userId;  // 视现有 auth shape

    const queryParsed = querySchema.safeParse({ taskId: c.req.param('taskId') });
    if (!queryParsed.success) throw new ValidationError(queryParsed.error.message);
    const { taskId } = queryParsed.data;

    const body = await c.req.json();
    const bodyParsed = bodySchema.safeParse(body);
    if (!bodyParsed.success) throw new ValidationError(bodyParsed.error.message);
    const { storeId, progressType, channel, callId, messageId, note, nextDueAt } = bodyParsed.data;

    const storeAuth = await getAuthorizedStoreNeon(userId, storeId);
    if (storeAuth.status === 'not_found') throw new NotFoundError('Store');
    if (storeAuth.status === 'forbidden') throw new ForbiddenError('No access to this store');
    if (storeAuth.role === 'VIEWER') throw new ForbiddenError('Viewers cannot modify tasks');

    const sql = getNeonClient();

    const result = await buildTaskActionSQL(
      {
        action: 'record_progress',
        payload: {
          taskId,
          progressType,
          channel,
          callId,
          messageId,
          note,
          nextDueAtOverride: nextDueAt ? new Date(nextDueAt) : undefined,
        },
      },
      {
        storeId,
        actor: { type: 'staff', id: userId, name: staffName },
        db: sql as any,
      } as any,
    );

    if (result.status === 'reject') {
      switch (result.reason) {
        case 'hallucinated_task_id': throw new NotFoundError('Task');
        case 'task_not_open': throw new ConflictError('Task is not open');
        case 'dnc': throw new ValidationError('Cannot record progress for DNC contact');
        case 'invalid_progress_type': throw new ValidationError(`invalid progressType: ${result.details}`);
        case 'duplicate':
          /*
           * Idempotency hit — ON CONFLICT idempotency_key DO NOTHING.
           * Return ok+deduped so client retries are silently safe.
           */
          return c.json({ data: { ok: true, deduped: true } });
        case 'store_mismatch': throw new NotFoundError('Task');
        default: throw new ValidationError(result.details ?? `rejected: ${result.reason}`);
      }
    }

    /*
     * B2 — sql.transaction wraps:
     *   1. CTE: INSERT task_progress_events ON CONFLICT (idempotency_key) DO NOTHING
     *           + UPDATE tasks SET attempt_count = attempt_count + 1 (only if INSERT fired)
     *   2. INSERT contact_timeline (task.progress_recorded)
     * Plus resultChecks(spec §3.1 line 251)— idempotency_key duplicate 是
     * 预期 retry,log warn 但不 throw(progress 是 idempotent operation)。
     */
    const txResults = await sql.transaction(result.statements.map(stmt => sql(stmt.sql, stmt.params)));
    checkSilentReject(result.resultChecks, txResults, { taskId, userId }, 'record_progress', { allowDuplicate: true });

    logger.info('Progress recorded', { taskId, progressType, channel, userId });

    return c.json({ data: { ok: true } });
  });

// apps/api/src/routes/tasks/index.ts (添加)
import { progressRoute } from './progress.ts';

const tasks = new Hono()
  // ... existing routes
  .route('/', progressRoute);  // POST /v2/tasks/:taskId/progress

it('idempotent same (taskId, callId, progressType) — attempt_count not double-bumped', async () => {
  const { taskId, storeId } = await seedTask({ status: 'open', attempt_count: 0 });
  const body = {
    storeId,
    progressType: 'no_answer',
    channel: 'phone',
    callId: 'CALL_X',
  };
  const r1 = await testApp.request(`/v2/tasks/${taskId}/progress`, {
    method: 'POST', body: JSON.stringify(body),
    headers: { 'Content-Type': 'application/json' },
  });
  const r2 = await testApp.request(`/v2/tasks/${taskId}/progress`, {
    method: 'POST', body: JSON.stringify(body),
    headers: { 'Content-Type': 'application/json' },
  });
  expect(r1.status).toBe(200);
  expect(r2.status).toBe(200);
  const r2body = await r2.json();
  expect(r2body.data.deduped).toBe(true);

  const task = await getTaskRow(taskId);
  expect(task.attempt_count).toBe(1);  // ← CTE 保护:不翻倍

  const events = await getProgressEvents(taskId);
  expect(events).toHaveLength(1);  // ← 只 1 行 event
});

// 改 line 18:
status: 'pending' | 'open' | 'closed';  // transitional;Plan 07 cutover 后收缩到 'open' | 'closed'

// 删 line 16:
// task_type: string;   ← 删除

// 删 line 20-21:
// action_needed: boolean;
// action_needed_reason: string | null;

// Before (line 109-118):
SELECT
  c.phone, c.first_name, c.last_name, c.lifecycle_stage,
  c.lead_status, c.purchase_intent, c.has_card_on_file,
  c.do_not_contact, c.action_needed, c.has_open_complaint,
  c.last_activity_at, c.created_at,
  COALESCE(cs.call_count, 0)::integer AS call_count,
  COALESCE(ss.sms_count, 0)::integer AS sms_count
FROM contacts c
LEFT JOIN call_stats cs ON cs.phone = c.phone
LEFT JOIN sms_stats ss ON ss.phone = c.phone
WHERE ${conditions.join(' AND ')}

// After:
SELECT
  c.phone, c.first_name, c.last_name, c.lifecycle_stage,
  c.lead_status, c.purchase_intent, c.has_card_on_file,
  c.do_not_contact,
  c.action_needed,                              -- 字段保留,Phase 2 才 DROP
  /*
   * Phase 1: has_open_task EXISTS subquery is the new source of truth
   * for "this contact has work pending". Frontend should consume
   * has_open_task; c.action_needed kept for backward compat until
   * Phase 2 ships its DROP COLUMN migration.
   *
   * Transitional: status IN ('pending', 'open') covers both legacy
   * 'pending' rows (pre-Plan 01) and new 'open' rows (post-Plan 01).
   */
  EXISTS (
    SELECT 1 FROM tasks t
    WHERE t.contact_phone = c.phone
      AND t.store_id = c.store_id
      AND t.status IN ('pending', 'open')
  ) AS has_open_task,
  c.has_open_complaint,
  c.last_activity_at, c.created_at,
  COALESCE(cs.call_count, 0)::integer AS call_count,
  COALESCE(ss.sms_count, 0)::integer AS sms_count
FROM contacts c
LEFT JOIN call_stats cs ON cs.phone = c.phone
LEFT JOIN sms_stats ss ON ss.phone = c.phone
WHERE ${conditions.join(' AND ')}

// Before:
const summaryQuery = `
  SELECT
    COUNT(*)::integer AS total,
    COUNT(*) FILTER (WHERE c.action_needed = true)::integer AS action_needed,
    COUNT(*) FILTER (WHERE c.created_at >= NOW() - INTERVAL '1 day')::integer AS new_today,
    COUNT(*) FILTER (WHERE c.last_activity_at < NOW() - INTERVAL '5 days')::integer AS stale_count
  FROM contacts c
  WHERE ${whereClause}
`;

// After:
const summaryQuery = `
  SELECT
    COUNT(*)::integer AS total,
    /*
     * Phase 1: action_needed KPI changes source — old denormalized
     * c.action_needed boolean replaced by an EXISTS subquery against
     * tasks. Transitional IN ('pending', 'open') covers Plan 01 window.
     * COUNT(DISTINCT c.phone) because a phone may have multiple
     * (phone, store_id) contact rows in legacy data.
     */
    COUNT(DISTINCT c.phone) FILTER (WHERE EXISTS (
      SELECT 1 FROM tasks t
      WHERE t.contact_phone = c.phone
        AND t.store_id = c.store_id
        AND t.status IN ('pending', 'open')
    ))::integer AS action_needed,
    COUNT(*) FILTER (WHERE c.created_at >= NOW() - INTERVAL '1 day')::integer AS new_today,
    COUNT(*) FILTER (WHERE c.last_activity_at < NOW() - INTERVAL '5 days')::integer AS stale_count
  FROM contacts c
  WHERE ${whereClause}
`;

/**
 * Attempt workload metric (Phase 1 口径迁移 — spec §4h B3).
 *
 * Phase 1 之前若 dashboard 用 tasks.close_result = 'attempted' 算 attempt
 * workload,Phase 1 这种 close_result 不存在了(progress 拆出来到 task_progress_events)。
 * 这里给出新口径的 helper。
 *
 * studio-api 当前 grep 无 close_result='attempted' 用法 — 本 helper 是预埋,
 * Phase 1.5 dashboard 改造时可直接消费。
 */
import { getNeonClient } from '../../../services/neon.ts';

export interface AttemptWorkloadRow {
  attempts: number;
  tasks_touched: number;
  active_staff: number;
}

export async function getAttemptWorkload(
  storeId: string,
  windowDays = 7,
): Promise<AttemptWorkloadRow> {
  const sql = getNeonClient();
  const rows = await sql.query(
    `SELECT
       COUNT(*)::int AS attempts,
       COUNT(DISTINCT task_id)::int AS tasks_touched,
       COUNT(DISTINCT actor_id) FILTER (WHERE actor_type = 'staff')::int AS active_staff
     FROM task_progress_events
     WHERE store_id = $1
       AND occurred_at >= NOW() - INTERVAL '${windowDays} days'`,
    [storeId],
  ) as unknown as AttemptWorkloadRow[];
  return rows[0] ?? { attempts: 0, tasks_touched: 0, active_staff: 0 };
}

// apps/api/src/__tests__/routes/dashboard-attempt-workload.test.ts
import { describe, it, expect } from 'vitest';
import { getAttemptWorkload } from '../../routes/v3/dashboard-helpers/attempt-workload.ts';
import { seedProgressEvent, resetTestDb } from '../helpers/test-db.ts';

describe('getAttemptWorkload', () => {
  it('counts progress events by store + actor distinct', async () => {
    await resetTestDb();
    const storeA = 'STORE_A';
    const taskA = 'task-A';
    const taskB = 'task-B';
    await seedProgressEvent({ taskId: taskA, storeId: storeA, actorType: 'staff', actorId: 'alice', progressType: 'no_answer', occurredAtDaysAgo: 0 });
    await seedProgressEvent({ taskId: taskA, storeId: storeA, actorType: 'staff', actorId: 'alice', progressType: 'left_voicemail', occurredAtDaysAgo: 1 });
    await seedProgressEvent({ taskId: taskB, storeId: storeA, actorType: 'staff', actorId: 'bob', progressType: 'no_answer', occurredAtDaysAgo: 2 });
    await seedProgressEvent({ taskId: taskB, storeId: storeA, actorType: 'system', actorId: 'cron', progressType: 'follow_up_scheduled', occurredAtDaysAgo: 3 });
    await seedProgressEvent({ taskId: taskA, storeId: storeA, actorType: 'system', actorId: 'cron', progressType: 'follow_up_scheduled', occurredAtDaysAgo: 4 });

    const r = await getAttemptWorkload(storeA, 7);
    expect(r.attempts).toBe(5);
    expect(r.tasks_touched).toBe(2);
    expect(r.active_staff).toBe(2);  // alice + bob distinct
  });

  it('tenant-isolates by store_id', async () => {
    await resetTestDb();
    await seedProgressEvent({ taskId: 'tA', storeId: 'STORE_A', actorType: 'staff', actorId: 'alice', progressType: 'no_answer' });
    await seedProgressEvent({ taskId: 'tB', storeId: 'STORE_B', actorType: 'staff', actorId: 'bob', progressType: 'no_answer' });
    const r = await getAttemptWorkload('STORE_A', 7);
    expect(r.attempts).toBe(1);
    expect(r.active_staff).toBe(1);
  });

  it('excludes events outside the window', async () => {
    await resetTestDb();
    await seedProgressEvent({ taskId: 'tA', storeId: 'STORE_A', actorType: 'staff', actorId: 'alice', progressType: 'no_answer', occurredAtDaysAgo: 10 });
    const r = await getAttemptWorkload('STORE_A', 7);
    expect(r.attempts).toBe(0);
  });
});

// apps/api/src/__tests__/integration/tasks-mutations.integration.test.ts
import { describe, it, expect, beforeEach } from 'vitest';
import { getNeonClient } from '../../services/neon.ts';
import {
  resetIntegrationDb,
  seedContact, seedTask, seedTimelineRow,
  callApi,
} from '../helpers/integration-helpers.ts';

describe('Phase 1 task mutations — E2E', () => {
  beforeEach(async () => { await resetIntegrationDb(); });

  it('close → UPDATE + timeline atomic', async () => {
    const { phone, storeId } = await seedContact({ doNotContact: false });
    const taskId = await seedTask({ phone, storeId, status: 'open', typeCategory: 'lead_follow_up' });
    const res = await callApi('PATCH', `/v2/tasks/close?taskId=${taskId}`, {
      storeId, staffName: 'Alice', closeResult: 'converted', note: '',
    });
    expect(res.status).toBe(200);
    const sql = getNeonClient();
    const [row] = await sql.query(`SELECT status FROM tasks WHERE task_id=$1`, [taskId]);
    expect(row.status).toBe('closed');
    const [tl] = await sql.query(`SELECT event_type FROM contact_timeline WHERE entity_id=$1`, [taskId]);
    expect(tl.event_type).toBe('task.status_changed');
  });

  it('progress idempotency — same (callId, progressType) twice → attempt_count not doubled (B8 CTE)', async () => {
    const { phone, storeId } = await seedContact({ doNotContact: false });
    const taskId = await seedTask({ phone, storeId, status: 'open', attempt_count: 0 });
    const body = { storeId, progressType: 'no_answer', channel: 'phone', callId: 'CALL_X' };
    await callApi('POST', `/v2/tasks/${taskId}/progress`, body);
    const r2 = await callApi('POST', `/v2/tasks/${taskId}/progress`, body);
    expect((await r2.json()).data.deduped).toBe(true);
    const sql = getNeonClient();
    const [row] = await sql.query(`SELECT attempt_count FROM tasks WHERE task_id=$1`, [taskId]);
    expect(row.attempt_count).toBe(1);
  });

  // ... 其他 5 scenarios
});