@tangle-network/create-agent-app 0.44.36

package/README.md

@@ -0,0 +1,9 @@
+# @tangle-network/create-agent-app
+
+Scaffold a new Tangle agent product on [`@tangle-network/agent-app`](https://github.com/tangle-network/agent-app):
+
+```bash
+npm create @tangle-network/agent-app@latest my-agent
+```
+
+Then `cd my-agent && pnpm install && pnpm typecheck && pnpm test`, and follow the generated `CUSTOMIZE.md` / `AGENTS.md`.

package/index.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// create-agent-app — scaffold a new Tangle agent product on @tangle-network/agent-app.
+//
+// Dependency-light by design: Node built-ins only. The CLI copies one template
+// tree verbatim (`template/` by default, `template-chat/` with `--chat`),
+// substitutes a small set of `__TOKEN__` placeholders, and renames
+// files whose template name would otherwise interfere with tooling (a template's
+// own `package.json` must not be read by the scaffolder's package manager; a
+// template `gitignore` must not be applied to the scaffolder repo). The generated
+// project's DATA surface is `agent.config.ts` + `knowledge/`; its CODE surface is
+// `src/` (the chat route + composer). The breadcrumb docs (AGENTS.md / CLAUDE.md /
+// CUSTOMIZE.md / KNOWLEDGE.md) ship inside the project so a coding agent that opens
+// it walks the trail with zero external context.
+
+import { cp, mkdir, readFile, readdir, rename, stat, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+// Template variants: the default tool-loop skeleton, and `--chat` — the
+// assembled multimodal chat vertical (auth + chat-store + chat-routes +
+// sandbox producer + uploads + replay) from `examples/chat-app.md`.
+const TEMPLATES = {
+  default: join(HERE, 'template'),
+  chat: join(HERE, 'template-chat'),
+}
+
+const { version: packageVersion } = JSON.parse(await readFile(join(HERE, 'package.json'), 'utf8'))
+const AGENT_APP_RANGE = `^${packageVersion}`
+
+// Template files renamed on materialization. A template cannot itself be named
+// `package.json` / `.gitignore` / `tsconfig.json` without confusing the
+// scaffolder repo's own tooling, so we prefix with `_` and restore on copy.
+const RENAME = new Map([
+  ['_package.json', 'package.json'],
+  ['_gitignore', '.gitignore'],
+  ['_tsconfig.json', 'tsconfig.json'],
+  ['_wrangler.toml', 'wrangler.toml'],
+])
+
+function parseArgs(argv) {
+  const args = { _: [] }
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a === '--name') args.name = argv[++i]
+    else if (a === '--agent-app-version') args.agentAppVersion = argv[++i]
+    else if (a === '--chat') args.template = 'chat'
+    else if (a === '--force') args.force = true
+    else if (a === '-h' || a === '--help') args.help = true
+    else if (!a.startsWith('-')) args._.push(a)
+    else throw new Error(`Unknown flag: ${a}`)
+  }
+  return args
+}
+
+function usage() {
+  return [
+    'Usage: create-agent-app <target-dir> [options]',
+    '',
+    'Scaffolds a new Tangle agent product on @tangle-network/agent-app.',
+    '',
+    'Options:',
+    '  --chat                       Scaffold the multimodal chat variant instead: the',
+    '                               assembled chat vertical (auth, thread/message store,',
+    '                               streaming turns + replay, uploads, agent asks) with',
+    '                               its own end-to-end test. Default: the tool-loop skeleton.',
+    '  --name <name>                Project name (default: the target dir basename).',
+    '  --agent-app-version <range>  @tangle-network/agent-app version (default: ' + AGENT_APP_RANGE + ').',
+    '  --force                      Write into a non-empty directory.',
+    '  -h, --help                   Show this help.',
+    '',
+    'After scaffolding:',
+    '  cd <target-dir> && pnpm install',
+    '  pnpm typecheck && pnpm test',
+    '  # then follow CUSTOMIZE.md (each template ships its own fill-checklist)',
+  ].join('\n')
+}
+
+// Project name → a safe npm package name (lowercase, dashes, no scope chars).
+function toPackageName(name) {
+  const cleaned = name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return cleaned || 'agent-app-product'
+}
+
+function applyTokens(content, tokens) {
+  let out = content
+  for (const [key, value] of Object.entries(tokens)) {
+    out = out.split(`__${key}__`).join(value)
+  }
+  return out
+}
+
+// Files we run token substitution on. Binary/asset files would be copied as-is;
+// the template is text-only, but we gate on extension to stay safe.
+const TEXT_EXT = /\.(ts|tsx|js|mjs|cjs|json|md|toml|txt|html|css|sql)$/i
+const TEXT_BASENAMES = new Set(['_gitignore', '.gitignore', '_package.json', 'package.json'])
+
+async function walk(dir, base = dir, out = []) {
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const abs = join(dir, entry.name)
+    const rel = abs.slice(base.length + 1)
+    if (entry.isDirectory()) await walk(abs, base, out)
+    else out.push(rel)
+  }
+  return out
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2))
+  if (args.help || (args._.length === 0 && !args.name)) {
+    process.stdout.write(usage() + '\n')
+    process.exit(args.help ? 0 : 1)
+  }
+
+  const targetDir = resolve(args._[0] ?? args.name)
+  const projectName = args.name ?? targetDir.split(/[\\/]/).pop()
+  const packageName = toPackageName(projectName)
+  const agentAppVersion = args.agentAppVersion ?? AGENT_APP_RANGE
+  const templateDir = TEMPLATES[args.template ?? 'default']
+
+  if (existsSync(targetDir)) {
+    const entries = await readdir(targetDir).catch(() => [])
+    const meaningful = entries.filter((e) => e !== '.git' && e !== '.DS_Store')
+    if (meaningful.length > 0 && !args.force) {
+      throw new Error(
+        `Target directory not empty: ${targetDir}\n` +
+          `Pass --force to scaffold into it anyway (will not overwrite the .git dir).`,
+      )
+    }
+  }
+  await mkdir(targetDir, { recursive: true })
+
+  const tokens = {
+    PROJECT_NAME: projectName,
+    PACKAGE_NAME: packageName,
+    AGENT_APP_VERSION: agentAppVersion,
+  }
+
+  const files = await walk(templateDir)
+  for (const rel of files) {
+    const src = join(templateDir, rel)
+    // Resolve any renamed path segments (only basenames are renamed).
+    const parts = rel.split(/[\\/]/)
+    const baseName = parts[parts.length - 1]
+    const outName = RENAME.get(baseName) ?? baseName
+    parts[parts.length - 1] = outName
+    const dest = join(targetDir, parts.join('/'))
+
+    await mkdir(dirname(dest), { recursive: true })
+
+    const isText = TEXT_EXT.test(baseName) || TEXT_BASENAMES.has(baseName)
+    if (isText) {
+      const raw = await readFile(src, 'utf8')
+      await writeFile(dest, applyTokens(raw, tokens))
+    } else {
+      await cp(src, dest)
+    }
+  }
+
+  process.stdout.write(
+    [
+      `Scaffolded ${projectName} → ${targetDir}`,
+      '',
+      'Next:',
+      `  cd ${targetDir}`,
+      '  pnpm install',
+      '  pnpm typecheck && pnpm test',
+      '',
+      'Then walk CUSTOMIZE.md (the fill-checklist) and AGENTS.md (the behavior contract).',
+      '',
+    ].join('\n'),
+  )
+}
+
+main().catch((err) => {
+  process.stderr.write(`create-agent-app: ${err.message}\n`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tangle-network/create-agent-app",
+  "version": "0.44.36",
+  "description": "Scaffold a new Tangle agent product on @tangle-network/agent-app: the tool-loop skeleton (default) or, with --chat, the assembled multimodal chat vertical (auth, chat store, streaming turns with replay, uploads, agent asks) with its own end-to-end test — plus the agent-followable breadcrumb docs (AGENTS.md / CUSTOMIZE.md).",
+  "keywords": [
+    "tangle",
+    "ai-agent",
+    "agent-framework",
+    "scaffold",
+    "create",
+    "cloudflare-workers"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tangle-network/agent-app.git",
+    "directory": "create-agent-app"
+  },
+  "bin": {
+    "create-agent-app": "./index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "template",
+    "template-chat"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/template/.dev.vars.example

@@ -0,0 +1,11 @@
+# Copy to .dev.vars for local `wrangler dev`. Do NOT commit .dev.vars.
+# Model resolves via resolveTangleModelConfig (see src/agent-app.ts).
+
+# Tangle Router (OpenAI-compatible, default path):
+TANGLE_API_KEY=
+MODEL_NAME=
+
+# BYOK Anthropic (set MODEL_PROVIDER=anthropic to use):
+# MODEL_PROVIDER=anthropic
+# ANTHROPIC_API_KEY=
+# ANTHROPIC_BASE_URL=https://api.anthropic.com

package/template/AGENTS.md

@@ -0,0 +1,67 @@
+# AGENTS.md — you are customizing an agent-app
+
+You are a coding agent working in a project generated by `create-agent-app`. This
+project is a thin customization layer on top of `@tangle-network/agent-app` (the
+shell) and the Tangle agent substrate (the engine). Walk this contract before you
+touch anything. It is a checklist, not prose — follow it in order.
+
+## 0. Orient
+
+- [ ] Read this file end to end.
+- [ ] Read `CUSTOMIZE.md` — the ordered fill-checklist. It is your task list.
+- [ ] Read `KNOWLEDGE.md` — how the build-loop vs the act-gate work.
+- [ ] Run `pnpm install && pnpm typecheck && pnpm test`. Confirm green BEFORE editing.
+
+## 1. The one rule (layering)
+
+> You change behavior by editing DATA and the COMPOSER — never by editing
+> `@tangle-network/agent-app`.
+
+- The shell (`@tangle-network/agent-app/*`) owns mechanism: the tool loop, the
+  agent→app tool side channel, the approval/proposal contract, the knowledge gate,
+  billing, crypto.
+- The engine (`@tangle-network/agent-eval`, `agent-runtime`, `agent-integrations`)
+  is a peer dependency. Do not bundle it, do not fork it.
+- You own: `agent.config.ts` (DATA) + `src/` (the COMPOSER + routes) + `knowledge/`
+  (DATA). That is the whole surface.
+
+## 2. DATA vs CODE — know which file you're in
+
+- [ ] DATA → `agent.config.ts`: identity, taxonomy, knowledge requirements/sources,
+      integrations, ui, model. Plain values. No control flow. No imports of engine
+      internals. If you're writing an `if`, you're in the wrong file.
+- [ ] DATA → `knowledge/`: domain documents. Content, not code. No secrets.
+- [ ] CODE → `src/agent-app.ts`: the COMPOSER. Wires config + bindings into the
+      shell's seams. Override ONE handler here only when the preset genuinely can't
+      express your persistence — default to the preset.
+- [ ] CODE → `src/worker.ts`: the chat route. Extend the route; recover trusted
+      per-turn context from real auth. Do not move domain values here.
+
+## 3. Invariants — fail-closed, never relax
+
+- [ ] HUMAN-IN-THE-LOOP: every regulated proposal type (`config.taxonomy.regulatedTypes`)
+      is routed to a named human and CANNOT auto-execute. Keep regulated types in
+      `regulatedTypes`. Never downgrade a regulated action to an immediate tool.
+- [ ] `regulatedTypes` ⊆ `proposalTypes`. The test enforces this; keep it green.
+- [ ] GROUNDING: never fabricate a domain figure (price, coverage, clause, id). A
+      real record or an explicit "NOT ON FILE". The persona fragment says this — keep it.
+- [ ] TRUSTED CONTEXT: `userId` / `workspaceId` / `threadId` come from the server
+      session, NEVER from model tool args. The model must not forge identity.
+- [ ] SOURCES ALWAYS RECORDED, PROPOSALS GATED: in the knowledge loop, grounding is
+      never dropped; a low-confidence knowledge PROPOSAL is. Propose, don't apply.
+
+## 4. Verify (every change ends here)
+
+- [ ] `pnpm typecheck` — clean. Proves `agent.config.ts` matches the shell contract.
+- [ ] `pnpm test` — green. Proves the composer wiring + invariants.
+- [ ] `pnpm knowledge:ingest` — enumerates your docs + sources (DRY) without error.
+- [ ] For a real deploy: `pnpm dev` (wrangler) after filling `wrangler.toml`.
+
+If any of these is red, you are not done. Do not weaken a test to pass.
+
+## 5. The schema floor
+
+`agent.config.ts` is validated by the TypeScript type `AgentAppConfig` from
+`@tangle-network/agent-app/config`. A non-TS agent can read the same shape from its
+JSON Schema: `agentAppConfigJsonSchema` (exported from that subpath). That schema +
+this file + `CUSTOMIZE.md` are the complete spec for what you may put where.

package/template/CLAUDE.md

@@ -0,0 +1,6 @@
+# CLAUDE.md
+
+The behavior contract for this project lives in `AGENTS.md`. Read it first, then
+walk `CUSTOMIZE.md` (the fill-checklist) and `KNOWLEDGE.md` (build-loop vs act-gate).
+
+@AGENTS.md

package/template/CUSTOMIZE.md

@@ -0,0 +1,83 @@
+# CUSTOMIZE.md — fill this project, in order
+
+This is the trail. Walk it top to bottom. Each step is a checklist item paired with
+the DISCOVERY QUESTION it answers — answer the question, then make the edit. The
+whole job is filling `agent.config.ts` (DATA) and seeding `knowledge/` (DATA). You
+touch `src/` only at step ⑤ and only if the preset can't express your stack.
+
+When every box is checked and `pnpm typecheck && pnpm test && pnpm knowledge:ingest`
+are green, the agent is customized.
+
+---
+
+## ① Identity — `agent.config.ts` → `identity`
+
+Discovery: **Whose job does this agent do, in whose voice, under what hard rules?**
+
+- [ ] Set `identity.name` to the product/agent name.
+- [ ] Rewrite `identity.persona` as the real one-paragraph role + voice + remit. This
+      is the spine of the system prompt.
+- [ ] Add hard rules + standing-workflow summaries to `systemPromptFragments`.
+- [ ] Keep/edit the grounding rule and the `not-advice` disclaimer. Add any
+      regulatory notice your domain requires under `disclaimers`.
+
+## ② Taxonomy — `agent.config.ts` → `taxonomy`
+
+Discovery: **Which actions change client state or are legally gated, so a certified
+human must approve before they execute?**
+
+- [ ] List every action the agent can PROPOSE in `proposalTypes`.
+- [ ] Put the regulated/state-changing subset in `regulatedTypes`. These cannot
+      auto-execute — they fail-closed to the approval queue.
+- [ ] Confirm `regulatedTypes` ⊆ `proposalTypes` (the test checks this).
+
+## ③ Knowledge requirements (the ACT gate) — `agent.config.ts` → `knowledge.requirements`
+
+Discovery: **What is the minimum the agent must have GROUNDED before it's allowed to
+propose? What facts gate the loop?**
+
+- [ ] For each gating fact, add a `KnowledgeRequirementSpec` with a declarative
+      `satisfiedBy`:
+  - a config field is set → `{ config: 'dot.path', nonEmpty: true }`
+  - rows exist in a workspace-scoped table → `{ table: 'name', minRows: N, statusIn: [...] }`
+  - combine with `{ anyOf: [...] }` / `{ allOf: [...] }`
+- [ ] Use a `derive` function ONLY for a rule the declarative form can't express.
+- [ ] Pick a real `category` / `acquisitionMode` / `importance` per spec (the
+      autocomplete lists the allowed values).
+
+## ④ Domain docs + research sources — `knowledge/` + `agent.config.ts` → `knowledge.sources`
+
+Discovery: **What does the agent need to READ to be grounded, and where does fresh
+knowledge come from?**
+
+- [ ] Drop your real domain documents into `knowledge/` (md/txt/json, one topic per
+      file). See `knowledge/README.md`.
+- [ ] List external research sources in `knowledge.sources` (URLs, regulation feeds,
+      integration refs) with a `kind`.
+- [ ] Tune `knowledge.loop` (`goal`, `minConfidence`, `freshness`) — see KNOWLEDGE.md.
+
+## ⑤ Integrations — `agent.config.ts` → `integrations.enabled` (+ `src/` only if needed)
+
+Discovery: **Which CRMs / data sources / messaging channels does the workflow touch?**
+
+- [ ] Add the `@tangle-network/agent-integrations` catalog kinds to `enabled`.
+- [ ] Only if the house preset can't persist your data: override a single handler in
+      `src/agent-app.ts`. Default to the preset; do not fork the shell.
+
+## ⑥ Ingest — `pnpm knowledge:ingest`
+
+Discovery: **Did the loop pick up exactly the docs and sources I expect?**
+
+- [ ] Run `pnpm knowledge:ingest` (DRY). Confirm the listed docs + sources match.
+- [ ] Wire a model-backed driver + decider, then `pnpm knowledge:ingest --run` to
+      drive the acquisition loop (see KNOWLEDGE.md).
+
+## ⑦ Verify
+
+Discovery: **Does the customized agent hold its contract?**
+
+- [ ] `pnpm typecheck` — clean.
+- [ ] `pnpm test` — green (invariants + composer wiring).
+- [ ] `pnpm knowledge:ingest` — enumerates without error.
+- [ ] Fill `wrangler.toml` (D1 id, KV id, `MODEL_NAME`), run the preset migration,
+      then `pnpm dev` to exercise `/chat` for real.

package/template/KNOWLEDGE.md

@@ -0,0 +1,73 @@
+# KNOWLEDGE.md — the build-loop and the act-gate
+
+Two different things share the word "knowledge". Keep them straight.
+
+## The two loops
+
+- BUILD LOOP (acquire) — `pnpm knowledge:ingest` → `@tangle-network/agent-app/knowledge-loop`.
+  Reads `knowledge/` + `agent.config.ts` `knowledge.sources`, researches, and
+  PROPOSES grounded knowledge pages. Source-grounded, propose-don't-apply.
+- ACT GATE (block) — `knowledge.requirements` in `agent.config.ts`, scored at runtime
+  by the Cloudflare preset's `KnowledgeStateAccessor`. Decides whether the agent
+  KNOWS enough to be allowed to propose an action.
+
+Build fills the well; the gate decides if the well is deep enough to act. They are
+configured separately and run at different times (ingest is offline/Node; the gate
+is per-request).
+
+## Build loop — how to drive it
+
+- [ ] Put domain docs in `knowledge/` and external sources in `knowledge.sources`.
+- [ ] `pnpm knowledge:ingest` (DRY) — confirms inputs without spending model calls.
+- [ ] Wire a model-backed `driver` and run `--run`:
+
+```ts
+import { createKnowledgeLoop } from '@tangle-network/agent-app/knowledge-loop'
+import { config } from '../agent.config'
+
+const loop = createKnowledgeLoop(config.knowledge, {
+  root: 'knowledge',                       // a KB layout on disk (Node only)
+  driver: async ({ systemPrompt, userMessage }) =>
+    ({ finalText: await callYourModel(systemPrompt, userMessage) }),
+  defaultMinConfidence: config.knowledge.loop?.minConfidence ?? 0.7,
+})
+const result = await loop.run()
+```
+
+Runs in Node (it touches the filesystem). NEVER on the Worker edge path — drive it
+from `scripts/knowledge-ingest.mjs`, CI, or a sandbox/delegation context.
+
+## Multimodal sources
+
+The default source adapter is text. To ingest audio / video / image sources, pass a
+`SourceAdapter` for that medium via `deps.adapters` — it is tried BEFORE text, so it
+claims its media first:
+
+```ts
+createKnowledgeLoop(config.knowledge, {
+  root: 'knowledge',
+  adapters: [audioSourceAdapter],   // tried before the built-in text adapter
+  driver,
+})
+```
+
+Declare such sources in `agent.config.ts` with a `kind` your adapter recognizes
+(e.g. `{ uri: 'vault://calls/2026-06.m4a', kind: 'audio' }`).
+
+## Tuning the gate (judges / confidence / freshness)
+
+The build loop accepts a pluggable decider — an agentic judge OR a deterministic /
+sandbox check. Defaults to a reviewer that applies a candidate's proposal only when
+`confidence >= minConfidence`; below it the proposal is dropped but its SOURCES are
+still recorded.
+
+- CONFIDENCE — raise `knowledge.loop.minConfidence` to demand stronger grounding
+  before a proposed page is accepted; lower it to accept more, weaker candidates.
+- JUDGE — pass a custom `decide` (a `KnowledgeDecider`) to replace the default
+  reviewer with your own judge (LLM-as-judge, lint, or sandbox verification).
+- FRESHNESS — set `knowledge.loop.freshness` (e.g. `static` / `session` / `daily`);
+  the decider receives it to decide whether cached knowledge is still valid.
+
+Per-requirement freshness on the ACT gate is set on each
+`KnowledgeRequirementSpec.freshness` — that controls how stale a satisfied
+requirement may be before the gate stops crediting it.

package/template/README.md

@@ -0,0 +1,41 @@
+# __PROJECT_NAME__
+
+A Tangle agent product scaffolded with `create-agent-app`, built on
+[`@tangle-network/agent-app`](https://github.com/tangle-network/agent-app) (the
+application-shell framework) + the Cloudflare preset (D1 + Drizzle + KV).
+
+## Layout
+
+| Path | Surface | Edit when |
+|---|---|---|
+| `agent.config.ts` | DATA — identity, taxonomy, knowledge gate, integrations | defining the agent |
+| `knowledge/` | DATA — domain documents the agent grounds on | adding domain knowledge |
+| `src/agent-app.ts` | CODE — the composer (config + bindings → shell seams) | overriding a handler |
+| `src/worker.ts` | CODE — the chat route | extending the route / auth |
+| `scripts/knowledge-ingest.mjs` | the build-loop entry (`pnpm knowledge:ingest`) | ingesting knowledge |
+
+## Get started
+
+```bash
+pnpm install
+pnpm typecheck && pnpm test
+```
+
+Then walk the trail:
+
+1. `AGENTS.md` — the behavior contract (you are customizing an agent-app).
+2. `CUSTOMIZE.md` — the ordered fill-checklist.
+3. `KNOWLEDGE.md` — build-loop vs act-gate.
+
+## Scripts
+
+- `pnpm dev` — run the worker locally (fill `wrangler.toml` first).
+- `pnpm typecheck` — `tsc --noEmit`.
+- `pnpm test` — vitest.
+- `pnpm knowledge:ingest` — enumerate + drive the knowledge acquisition loop.
+- `pnpm deploy` — `wrangler deploy`.
+
+## Invariants
+
+Regulated proposals are human-approved and never auto-execute. Domain figures are
+grounded in real records, never fabricated. See `AGENTS.md` for the full contract.

package/template/_gitignore

@@ -0,0 +1,5 @@
+node_modules
+dist
+.wrangler
+.dev.vars
+*.log

package/template/_package.json

@@ -0,0 +1,33 @@
+{
+  "name": "__PACKAGE_NAME__",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "wrangler dev",
+    "deploy": "wrangler deploy",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "knowledge:ingest": "node scripts/knowledge-ingest.mjs"
+  },
+  "dependencies": {
+    "@tangle-network/agent-app": "__AGENT_APP_VERSION__"
+  },
+  "peerDependencies": {
+    "@tangle-network/agent-eval": "0.135.1",
+    "@tangle-network/agent-integrations": ">=0.44.0",
+    "@tangle-network/agent-interface": "0.36.0",
+    "@tangle-network/agent-runtime": "0.109.0"
+  },
+  "devDependencies": {
+    "@tangle-network/agent-eval": "0.135.1",
+    "@tangle-network/agent-integrations": "^0.44.0",
+    "@tangle-network/agent-interface": "0.36.0",
+    "@tangle-network/agent-runtime": "0.109.0",
+    "@types/node": "^25.6.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0",
+    "wrangler": "^4.0.0"
+  }
+}

package/template/_tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["agent.config.ts", "src", "tests"]
+}

package/template/_wrangler.toml

@@ -0,0 +1,22 @@
+name = "__PACKAGE_NAME__"
+main = "src/worker.ts"
+compatibility_date = "2025-01-01"
+compatibility_flags = ["nodejs_compat"]
+
+# The house Cloudflare stack the preset composes: D1 + KV.
+# Run `wrangler d1 create __PACKAGE_NAME__` and paste the database_id; create a
+# KV namespace and paste its id. Then run the preset migration (see CUSTOMIZE.md ⑥).
+
+[[d1_databases]]
+binding = "DB"
+database_name = "__PACKAGE_NAME__"
+database_id = "REPLACE_WITH_D1_DATABASE_ID"
+
+[[kv_namespaces]]
+binding = "VAULT"
+id = "REPLACE_WITH_KV_NAMESPACE_ID"
+
+# Model resolves from env via resolveTangleModelConfig (TANGLE_API_KEY / MODEL_NAME).
+# Put secrets in .dev.vars locally; `wrangler secret put` for production.
+[vars]
+MODEL_NAME = "REPLACE_WITH_MODEL"