6.cAsync / queue / batch backend pattern

1. Why async / queue / batch is its own SDK package

Lambda's 15-minute execution cap is the most common shape that breaks "Lambda + Function URL handles everything." When a vibe scripter writes code that processes a 100MB CSV, summarizes a long thread, or runs a multi-step agent — the work might not fit in a single Lambda invocation. Without a platform pattern, the vibe scripter writes their own SQS plumbing, their own DLQ handling, their own retry semantics. That's exactly the engineering-abstraction territory §19 specifies the engineering team to own.

The SDK provides three primitives that compose:

• Job queue: enqueue work for later; one or many workers consume; per-message retry + DLQ
• Scheduled job: EventBridge-driven; runs on a cron; wrapper handles single-instance guarantees
• Step Function workflow: for orchestrated multi-step work that needs the >15min escape hatch

2. SDK surface — vibe-scripter ergonomic

Enqueue a job

// In any vibe app's route handler — vibe scripter writes:
import { queue } from 'vibecode-sdk';

await queue.enqueue('process-csv', {
  csvKey: 'uploads/2026-05-sales.csv',
  ownerId: ctx.user.id,
  reportId: report.id,
});
// Returns; the worker handles the rest.

Define a worker

// cartridges/sales/monthly-reports/workers/process-csv.js
import { worker } from 'vibecode-sdk';

export default worker('process-csv', async (payload, ctx) => {
  const { csvKey, ownerId, reportId } = payload;

  // Stream the CSV (vibecode/sdk/v1/data/documentStore handles this)
  const stream = await ctx.store.documents.stream(csvKey);

  // Process row-by-row, emit audit events
  for await (const row of stream) {
    await ctx.audit.emit({ op: 'csv.row.processed', payload: { reportId, rowIndex: row.idx } });
    // ... business logic
  }

  await ctx.store.documents.put(`reports/${reportId}.json`, summary);
});
// Worker returns; SDK acks the SQS message. Failure throws → SDK NACKs → retry.

Scheduled job

// cartridges/engineering/obs/scheduled/daily-narrative.js
import { scheduled } from 'vibecode-sdk';

export default scheduled('daily-narrative', {
  cron: 'cron(0 13 * * ? *)',  // 09:00 ET / 13:00 UTC
  handler: async (ctx) => {
    const narrative = await ctx.agent.invokeAgentSync({
      model: 'claude-haiku-4-5',
      messages: [{ role: 'user', content: 'Summarize yesterday...' }],
      attribution: { app: 'obs', purpose: 'daily_narrative', cell: 'eng-low-risk' },
    });
    await ctx.cache.put('narrative', narrative);
  },
});

Step Function workflow (for >15 min)

import { workflow } from 'vibecode-sdk';

export default workflow('large-csv-import', {
  steps: [
    { name: 'split-csv', handler: async (payload, ctx) => { ... return chunks; } },
    { name: 'process-each-chunk', map: true, handler: async (chunk, ctx) => { ... } },
    { name: 'merge-and-publish', handler: async (results, ctx) => { ... } },
  ],
});

3. Contracts that carry over

4. Substrate primitives

Per-app substrate (provisioned by the cartridge's Terraform via the app-template):

• SQS queue: ai-sandbox-<app>-jobs
• SQS DLQ: ai-sandbox-<app>-jobs-dlq (3-retry threshold)
• EventBridge rule(s) for scheduled jobs declared by the app
• Step Functions state machine(s) for declared workflows (only when needed)
• DDB job-state table for workflow state + idempotency keys

Cross-app substrate (shared):

• Single SQS queue + DLQ alarms aggregated to the obs app's observability tab
• Substrate-level audit log group receives every job's audit events

5. Failure modes — what each layer catches

6. When this gets built

Phase B, alongside vibe app 2 (Sales monthly reports). The CSV ingest is the first consumer; engineering team builds the SDK packages against this spec; vibe app 2 ships consuming them. By Phase C, vibe app 3's likely needs (scheduled reports, agent workflows) inherit the same SDK with zero additional engineering.

7. Doctrine