Action Items

Context (approved)
  └─► strategy-writer
        └─► Strategy (approved)
              └─► deliverable-planner
                    ├─► Goals[]
                    ├─► DeliverableTemplate[]     (recurring, monthly)
                    └─► ActionItem[]              (one-time, period-assigned)
                          └─► Plan approved
                                └─► activity-planner (per period)
                                      ├─► Activities from DeliverableTemplates
                                      └─► Activities from ActionItems assigned to this period

model ActionItem {
  id                 String            @id @default(cuid())
  deliverablePlanId  String
  deliverablePlan    DeliverablePlan   @relation(fields: [deliverablePlanId], references: [id])
  tenantId           String
  goalId             String?
  goal               Goal?             @relation(fields: [goalId], references: [id])
 
  title              String
  description        String
  agentQueue         String            // e.g. "agent__seo-optimizer"
  suggestedPeriod    Int               // 1-based relative period number
  rationale          String            // Claude's reasoning for the suggested period
  estimatedCost      Int               // credits
 
  status             ActionItemStatus  @default(pending_review)
  assignedPeriodId   String?           // set when activity-planner runs for that period
  deliverablePeriod  DeliverablePeriod? @relation(fields: [assignedPeriodId], references: [id])
 
  createdAt          DateTime          @default(now())
  updatedAt          DateTime          @updatedAt
 
  @@index([deliverablePlanId])
  @@index([tenantId])
}
 
enum ActionItemStatus {
  pending_review   // awaiting plan approval
  approved         // plan approved, waiting for its period to be reached
  in_progress      // activity-planner has created activities for this item
  done             // all activities completed
  skipped          // DM manually skipped it
}

model DeliverablePlan {
  // ... existing fields
  actionItems        ActionItem[]
  planStartDate      DateTime?    // set on plan approval
}

## Action Items

List one-time strategic tasks needed to achieve the goals above.
These are NOT recurring — each executes once in a specific period.

Rules:
- Suggest the period number (1 = first month of the plan) based on sequencing logic
- Front-load foundational work (audits, research, setup) in periods 1-2
- Sequence action items so dependencies come before execution tasks
- Link each to the goal it supports (use the goal's position index)
- Only include tasks that require an agent — no manual human tasks
- Maximum 8 action items per plan

Output as JSON array under key "actionItems".

interface DeliverablePlannerOutput {
  goals: Goal[]
  deliverableTemplates: DeliverableTemplate[]
  actionItems: ActionItemOutput[]           // new
  monthlyCostEstimate: number
  planningNotes: string
}
 
interface ActionItemOutput {
  title: string
  description: string
  goalIndex: number | null          // index into goals array
  agentQueue: string
  suggestedPeriod: number           // 1-based
  rationale: string
  estimatedCost: number
}

await db.actionItem.createMany({
  data: actionItems.map(item => ({
    deliverablePlanId: plan.id,
    tenantId,
    goalId: item.goalIndex !== null ? savedGoals[item.goalIndex].id : null,
    title: item.title,
    description: item.description,
    agentQueue: item.agentQueue,
    suggestedPeriod: item.suggestedPeriod,
    rationale: item.rationale,
    estimatedCost: item.estimatedCost,
    status: "pending_review",
  }))
})

const planStartDate = `${year}-${month}-01`  // string formatting, not toISOString()
await db.deliverablePlan.update({
  where: { id: planId },
  data: { status: "approved", planStartDate }
})

function resolvePeriodDate(planStartDate: string, periodNumber: number): string {
  const [year, month] = planStartDate.split("-").map(Number)
  const targetMonth = month + periodNumber - 1
  const y = year + Math.floor((targetMonth - 1) / 12)
  const m = ((targetMonth - 1) % 12) + 1
  return `${y}-${String(m).padStart(2, "0")}-01`
}

const periodNumber = computePeriodNumber(plan.planStartDate, periodStart)
 
const actionItemsForPeriod = await db.actionItem.findMany({
  where: {
    deliverablePlanId: plan.id,
    suggestedPeriod: periodNumber,
    status: "approved",
  }
})

## One-Time Action Items for This Period

The following one-time tasks must also be sequenced this period:

| # | Title | Description | Agent Queue |
|---|---|---|---|
| 1 | Technical SEO Audit | Full crawl and issue report | agent__seo-optimizer |

Treat these as regular activities. Assign due dates and dependencies as appropriate.
Flag them with isOneTime: true in the output.

PATCH /tenant/v1/action-items/:id
Body: { suggestedPeriod: number }

deliverable-planner generates action items (status: pending_review)
  └─► Shown on /strategy/deliverable-plan alongside goals and templates
        └─► DM reviews, optionally edits suggestedPeriod
              └─► Client approves plan
                    └─► All action items → status: approved
                          └─► Each period: activity-planner picks up items for that period
                                └─► status: in_progress → done

// On refresh: delete only pending_review action items before re-running planner
await db.actionItem.deleteMany({
  where: { deliverablePlanId: planId, status: "pending_review" }
})

[ Goals ]
[ Deliverable Templates ]
[ Action Items ]              ← new
  ┌─────────────────────────────────────────────────────┐
  │ Title          │ Goal        │ Period  │ Rationale   │
  │ Tech SEO Audit │ +40% traffic│ Month 1 │ "Must run…" │
  │ Profile Optim. │ +25% social │ Month 1 │ "Before…"   │
  └─────────────────────────────────────────────────────┘
  DM can edit the Period column inline before approving.

Monthly recurring cost:   ₹ 4,200   (from deliverable templates)
One-time action items:    ₹   800   (sum of all action item estimatedCost)