Input (conversation/event)
    ↓
Store raw resource (S3)
    ↓
Create resource record (Postgres)
    ↓
Queue for extraction (SQS)
    ↓
Extract atomic facts (LLM)
    ↓
Classify by category
    ↓
Generate embeddings
    ↓
Write items to Postgres
    ↓
Evolve category summaries (LLM)
    ↓
Extract entities → Neo4j nodes
Extract relationships → Neo4j edges

// POST /memorize
async function memorize(request: MemorizeRequest) {
  // 1. Store to S3
  const s3Key = `${request.appId}/${request.userId}/${uuid()}.json`;
  await s3.putObject(bucket, s3Key, request.content);

  // 2. Create resource record
  const resource = await db.insert(memoryResources).values({
    appId: request.appId,
    userId: request.userId,
    s3Key,
    contentType: request.contentType,
    metadata: request.metadata,
  });

  // 3. Queue for extraction
  await sqs.sendMessage(extractionQueue, {
    resourceId: resource.id,
    appId: request.appId,
  });

  return { status: 'queued', resourceId: resource.id };
}

// Extraction prompt uses domain config
const extractionPrompt = `
You are extracting memories for ${config.appId}: ${config.description}

## Categories
${config.categories.map(c => `- ${c.name}: ${c.description}`).join('\n')}

## Entity Types
${config.entityTypes.map(e => `- ${e.name}: ${e.description}`).join('\n')}

## Content
${content}

Extract atomic facts, entities, and relationships as JSON.
`;

async function evolveSummary(
  existingSummary: string | null,
  newFacts: string[],
  config: CategoryDefinition
): Promise<string> {
  const prompt = `
You are updating a memory summary for category "${config.name}".
${config.description}

Existing summary:
${existingSummary || '(No existing summary)'}

New facts to incorporate:
${newFacts.map((f, i) => `${i + 1}. ${f}`).join('\n')}

Rules:
- If new facts contradict old information, use the new information
- Keep the summary concise but comprehensive
- Preserve important historical context
- Maximum 500 words

Updated summary:`;

  return await llm.complete(prompt);
}

async function handleRelationship(rel: ExtractedRelationship) {
  const relDef = config.relationshipTypes.find(r => r.name === rel.type);

  if (relDef?.exclusive) {
    // Archive any existing relationship of this type
    await neo4j.run(`
      MATCH (s:Entity {app_id: $appId, name: $subject})
            -[old:RELATES_TO {type: $type}]->(:Entity)
      WHERE old.archived = false
      SET old.archived = true, old.archived_at = datetime()
    `, { appId, subject: rel.subject, type: rel.type });
  }

  // Create new relationship
  await neo4j.run(`
    MATCH (s:Entity {app_id: $appId, name: $subject})
    MATCH (o:Entity {app_id: $appId, name: $object})
    CREATE (s)-[:RELATES_TO {
      type: $type,
      created_at: datetime(),
      archived: false,
      properties: $properties
    }]->(o)
  `, { appId, subject: rel.subject, object: rel.object, type: rel.type, properties: rel.properties });
}