In-App
Intelligence.

import { agentPool, chain } from '@lloyal-labs/lloyal-agents';
import { reportTool } from '@lloyal-labs/rig';
import { sources, workerPrompt } from './harness';

// Sequential agents. Each one's findings extend the spine; the
// next agent forks from the extended spine and sees prior findings
// in attention — not via re-prompting. KV grows; no re-encoding.
//
// workerPrompt gets the taskIndex, so step 0 establishes vocabulary
// and steps 1+ get a "build on prior research" preamble. See prompts.
const steps = ['discover', 'verify', 'distill'];
const pool = yield* agentPool({
  orchestrate: chain(steps, (step, i) => ({
    task: {
      content: `Step: ${step}`,
      systemPrompt: workerPrompt({ subject: step, taskIndex: i, maxTurns: 8 }),
    },
    userContent: `${step} findings:`,
  })),
  tools: [...sources.tools, reportTool],
  terminalToolName: 'report',
});

import { agentPool, dag } from '@lloyal-labs/lloyal-agents';
import { reportTool } from '@lloyal-labs/rig';
import { sources, investigatePrompt, comparePrompt, synthPrompt } from './harness';

// Declared dependency topology. Independent nodes run in parallel;
// dependent nodes wait, then fork from a spine that carries their
// dependencies' findings in attention. Each role gets its own prompt
// renderer — investigator, analyst, editor are all functions of the
// node's per-spawn data. See the prompts tab.
const pool = yield* agentPool({
  orchestrate: dag([
    { id: "research_x", task: { content: "Research subject X", systemPrompt: investigatePrompt({ subject: 'X' }) } },
    { id: "research_y", task: { content: "Research subject Y", systemPrompt: investigatePrompt({ subject: 'Y' }) } },
    { id: "compare",    task: { content: "Compare X vs Y",     systemPrompt: comparePrompt({ x: 'X', y: 'Y', axis: 'cost' }) },
      dependsOn: ["research_x", "research_y"] },
    { id: "synthesize", task: { content: "Write the report",    systemPrompt: synthPrompt({ subjects: ['X', 'Y'] }) },
      dependsOn: ["compare"] },
  ]),
  tools: [...sources.tools, reportTool],
  terminalToolName: 'report',
});

import { Source, type Reranker } from '@lloyal-labs/rig';
import { type Operation } from 'effection';
import { SearchCustomersTool, ReadCustomerTool } from './customer-tools';
import { db } from './app';

// Bridge your app's own data. Implementing Source slots your retrieval
// into the same pipeline as built-in Web and Corpus — same reranker,
// same focal-lens admission, same KV-resident results. No vector DB,
// no embedding ETL, no parallel knowledge layer. Your customer table
// becomes an agent-accessible source just by writing this class.
class CustomerSource extends Source<{ reranker: Reranker }> {
  readonly name = 'customers';
  readonly searchTool = new SearchCustomersTool(db);
  readonly readTool = new ReadCustomerTool(db);

  get tools() { return [this.searchTool, this.readTool]; }

  *bind(ctx: { reranker: Reranker }): Operation<void> {
    this.searchTool.setReranker(ctx.reranker);
  }

  getChunks() { return db.customers.iterate(); }
}

// Drop in alongside any other source — same wiring, same scorer.
const customers = new CustomerSource();
yield* customers.bind({ reranker });

import { renderTemplate } from '@lloyal-labs/lloyal-agents';

// The spine playbook block reshapes based on which apps the user
// has wired in. /web with no /scan = web-only catalog. /scan only
// = corpus-only. Both wired = both catalogs plus a cross-source
// boundary rule that's only relevant when the model has access
// to both palettes. The spine literally changes shape at runtime.
const PLAYBOOKS = `
# Playbooks
<% if (it.hasWeb) { -%>

## web_research
Tools: web_search, fetch_page
Use when: gathering evidence from the open web.
<% } -%>
<% if (it.hasCorpus) { -%>

## corpus_research
Tools: grep, read_file, search
Use when: investigating a local document corpus.
<% } -%>
<% if (it.hasWeb && it.hasCorpus) { -%>

# Cross-source rule
Apply only the playbook the agent system message names.
Do not mix tools across playbooks.
<% } -%>
`;

export const playbooks = (data) => renderTemplate(PLAYBOOKS, data);

// Used in withSpine — what's in the spine depends on what's installed:
//   systemPrompt: playbooks({ hasWeb: apps.has('web'), hasCorpus: apps.has('corpus') })

import { renderTemplate } from '@lloyal-labs/lloyal-agents';

// In a chain, the first task establishes vocabulary; later tasks
// build on what prior tasks surfaced. Task 0 gets a clean prompt.
// Tasks 1+ get an additional BUILD ON PRIOR RESEARCH preamble that
// points the model at conversation history it inherits via the spine
// — so it deepens or fills gaps instead of re-investigating.
const WORKER = `
You are investigating: <%= it.subject %>
<% if (it.taskIndex > 0) { -%>

BUILD ON PRIOR RESEARCH:
Prior tasks' findings are in your conversation history above —
inherited via the spine, not re-prompted. Read them first.
Identify named entities and open questions your task should
follow up on. Do not re-investigate covered ground; deepen
or fill gaps.
<% } -%>

You have <%= it.maxTurns %> tool calls.
`;

export const workerPrompt = (data) => renderTemplate(WORKER, data);

// Used in agentPool chain — the orchestrator passes the step index:
//   chain(steps, (step, i) => ({
//     task: { systemPrompt: workerPrompt({ subject: step, taskIndex: i, ... }) },
//   }))