zerodb-sequential-thinking-mcp 0.1.0

package/.env.example

@@ -0,0 +1,7 @@
+# Optional — set to receive claim link via email on first run
+ZERODB_EMAIL=
+
+# Optional — skip auto-provisioning, use existing ZeroDB credentials
+ZERODB_API_KEY=
+ZERODB_PROJECT_ID=
+ZERODB_BASE_URL=https://api.ainative.studio

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AINative Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,245 @@
+# ZeroDB Sequential Thinking MCP
+
+Persistent chain-of-thought reasoning for AI agents — reasoning chains survive sessions, resume across agents, and conclusions save as plan artifacts.
+
+**Agents self-provision a ZeroDB account on first run. No signup, no dashboard, no API key copy-paste.**
+
+---
+
+## What Makes This Different
+
+The upstream `@modelcontextprotocol/server-sequential-thinking` discards every reasoning chain when the session ends. This one doesn't.
+
+| Feature | Upstream | This package |
+|---------|----------|--------------|
+| Sequential reasoning steps | ✅ | ✅ |
+| Persists across sessions | ❌ | ✅ |
+| Resume prior chain by ID | ❌ | ✅ |
+| Save conclusion as plan artifact | ❌ | ✅ |
+| Agent self-provisioning | ❌ | ✅ |
+| Setup required | Manual | Zero |
+
+---
+
+## Agent Self-Provisioning
+
+This is the key capability: **the agent provisions its own ZeroDB account**. No human needs to visit a dashboard, create an account, or copy an API key.
+
+### How it works
+
+```
+Agent installs MCP → MCP boots → No credentials found →
+  POST /api/v1/instant-db (zero-auth, terms auto-accepted on behalf of user) →
+  ZeroDB account created (72h trial) →
+  API key + project ID written to ~/.zerodb/credentials.json →
+  Claim URL printed to stderr →
+  MCP ready — agent starts working immediately
+```
+
+**The agent does all of this in ~2 seconds on first boot.** Subsequent boots are silent — credentials are read from disk.
+
+### For agent swarms and multi-agent systems
+
+Each agent instance reads from `~/.zerodb/credentials.json`. In a shared environment (e.g. OpenClaw agent swarm, CrewAI, AutoGen multi-agent), set `ZERODB_CONFIG_DIR` to a shared path so all agents use the same project:
+
+```json
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "command": "npx",
+      "args": ["-y", "zerodb-sequential-thinking-mcp"],
+      "env": {
+        "ZERODB_CONFIG_DIR": "/shared/zerodb"
+      }
+    }
+  }
+}
+```
+
+Or provision once manually and share credentials via env vars:
+
+```json
+{
+  "env": {
+    "ZERODB_API_KEY": "zdb_live_...",
+    "ZERODB_PROJECT_ID": "your-project-id"
+  }
+}
+```
+
+### Claiming the provisioned account
+
+On first run you'll see this in stderr:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  ZeroDB account provisioned (72h trial)                     │
+│                                                             │
+│  Your reasoning chains are now persisted in ZeroDB.         │
+│  API key: tmp_xxxxxx...                                     │
+│                                                             │
+│  Claim your account to keep data permanently:               │
+│  → https://ainative.studio/claim?token=...&project=...      │
+│                                                             │
+│  Optional: set ZERODB_EMAIL=you@email.com in your MCP       │
+│  config to receive account details via email.               │
+│                                                             │
+│  This message won't appear again after you claim.           │
+└─────────────────────────────────────────────────────────────┘
+```
+
+Visit the claim URL, sign up or log in — your project transfers to your permanent account with a `zdb_live_` API key. All reasoning history is preserved.
+
+---
+
+## Install
+
+### Claude Code
+
+```bash
+npx zerodb-sequential-thinking-mcp
+```
+
+Or add to `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "command": "npx",
+      "args": ["-y", "zerodb-sequential-thinking-mcp"]
+    }
+  }
+}
+```
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "sequential-thinking": {
+      "command": "npx",
+      "args": ["-y", "zerodb-sequential-thinking-mcp"],
+      "env": {
+        "ZERODB_EMAIL": "you@email.com"
+      }
+    }
+  }
+}
+```
+
+### Cursor / Windsurf / Cline / Continue
+
+Add to your IDE's MCP settings. Same config as above — `command: npx`, `args: ["-y", "zerodb-sequential-thinking-mcp"]`.
+
+### OpenClaw / CrewAI / AutoGen / LangChain agent systems
+
+For agent swarms, provision once then share credentials via `ZERODB_API_KEY` + `ZERODB_PROJECT_ID` env vars across all agent instances. All agents write to the same ZeroDB project — reasoning chains from any agent are resumable by any other agent.
+
+---
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `ZERODB_EMAIL` | No | Receive the claim link + account details via email after auto-provisioning |
+| `ZERODB_API_KEY` | No | Skip auto-provisioning — use an existing ZeroDB key (e.g. after claiming) |
+| `ZERODB_PROJECT_ID` | No | Required when `ZERODB_API_KEY` is set |
+| `ZERODB_BASE_URL` | No | Override API base (default: `https://api.ainative.studio`) |
+| `ZERODB_CONFIG_DIR` | No | Override credentials directory (default: `~/.zerodb`) |
+
+---
+
+## Tools
+
+### `sequential_think`
+
+Perform a sequential reasoning step. Chain multiple calls for complex, multi-step problems.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `thought` | string | Yes | The current reasoning step |
+| `chain_id` | string | No | Chain ID — auto-generated on first call, pass on subsequent steps |
+| `step_number` | number | No | Current step number |
+| `total_steps` | number | No | Estimated total steps |
+| `next_step` | string | No | What to reason about next |
+| `is_final` | boolean | No | Is this the last step before concluding? |
+| `persist_steps` | boolean | No | Store each step in ZeroDB working memory (default: `false`) |
+
+### `sequential_conclude`
+
+Finalize a reasoning chain and save the conclusion as a persistent ZeroDB plan artifact. Returns an `artifact_id` you can pass to `sequential_resume` in any future session or agent.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `conclusion` | string | Yes | The final answer or decision |
+| `chain_id` | string | No | Chain ID from prior `sequential_think` calls |
+| `title` | string | No | Artifact title (defaults to first 60 chars of conclusion) |
+| `save_as` | string | No | `plan`, `prd`, or `task` (default: `plan`) |
+
+### `sequential_resume`
+
+Load a prior reasoning chain from ZeroDB and continue from where it left off — in any session, on any agent.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `artifact_id` | string | Yes | ID returned by a prior `sequential_conclude` call |
+
+---
+
+## Example: Multi-Session, Multi-Agent Reasoning
+
+**Agent A, Session 1 — Deep analysis:**
+```
+sequential_think: thought="Analyze architecture options for a payments service"
+sequential_think: thought="Team is 4 engineers, 18-month runway, compliance required"
+sequential_think: thought="Stripe + monolith wins on speed, microservices wins on scale"
+sequential_conclude:
+  conclusion="Use Stripe + monolith now. Extract payments microservice at $1M ARR."
+  title="Payments Architecture Decision"
+→ artifact_id: "f3a9-..."
+```
+
+**Agent B, Session 2 — Resume and extend (different agent, different session):**
+```
+sequential_resume: artifact_id="f3a9-..."
+→ Prior conclusion loaded: "Use Stripe + monolith now..."
+sequential_think: thought="We've hit $1M ARR. Revisiting the migration trigger."
+sequential_conclude:
+  conclusion="Begin payments microservice extraction. Start with webhook handler."
+  title="Payments Architecture v2"
+→ artifact_id: "b72c-..."
+```
+
+The `artifact_id` is the only thing that needs to pass between agents or sessions. Everything else is retrieved from ZeroDB.
+
+---
+
+## How Credentials Work
+
+```
+First run:
+  ~/.zerodb/credentials.json created automatically
+  { api_key: "tmp_...", project_id: "...", claimed: false, expires_at: "..." }
+
+After claiming:
+  { api_key: "zdb_live_...", project_id: "...", claimed: true }
+  Silent boot from here on — no banner, no provisioning calls
+
+Power user override (env vars take precedence over credentials file):
+  ZERODB_API_KEY + ZERODB_PROJECT_ID → skips all provisioning
+```
+
+---
+
+## Powered by ZeroDB
+
+[ZeroDB](https://ainative.studio) — the agent memory and storage platform built for agentic AI. Every reasoning chain, plan artifact, and working memory record is stored in ZeroDB's `memories` table with vector embeddings for semantic recall.
+
+- **Plan artifacts API:** `POST/GET/PATCH /api/v1/public/memory/v2/plan`
+- **Memory API:** `POST /api/v1/public/memory/v2/remember`
+- **Instant provisioning:** `POST /api/v1/instant-db`
+- **Docs:** [ainative.studio/docs](https://ainative.studio/docs)

package/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { provision } from './src/provision.js';
+import { ZeroDBClient } from './src/zerodb.js';
+import { TOOLS, executeTool } from './src/tools.js';
+
+async function main() {
+  const credentials = await provision();
+  const client = new ZeroDBClient(credentials);
+
+  const server = new Server(
+    { name: 'zerodb-sequential-thinking-mcp', version: '0.1.0' },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      const result = await executeTool(name, args || {}, client);
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result) }]
+      };
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }],
+        isError: true
+      };
+    }
+  });
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  process.stderr.write('ZeroDB Sequential Thinking MCP v0.1.0 — ready\n');
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal: ${err.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "zerodb-sequential-thinking-mcp",
+  "version": "0.1.0",
+  "description": "Persistent sequential thinking MCP — chain-of-thought reasoning that survives sessions, resumes across agents, and saves conclusions as plan artifacts. Powered by ZeroDB. Zero-config: agents self-provision a ZeroDB account on first run, no signup required.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "zerodb-sequential-thinking-mcp": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "mcp-server-hosting",
+    "model-context-protocol",
+    "model-context-protocol-server",
+    "sequential-thinking",
+    "sequential-reasoning",
+    "chain-of-thought",
+    "chain-of-thought-reasoning",
+    "reasoning",
+    "multi-step-reasoning",
+    "problem-solving",
+    "structured-thinking",
+    "deep-thinking",
+    "self-provisioning",
+    "agent-provisioning",
+    "zero-config",
+    "auto-provisioning",
+    "zero-signup",
+    "instant-setup",
+    "agent-onboarding",
+    "agent-memory",
+    "persistent-memory",
+    "cross-session",
+    "cross-session-memory",
+    "cross-session-reasoning",
+    "plan-artifacts",
+    "context-management",
+    "context-window",
+    "conversation-history",
+    "long-term-memory",
+    "zerodb",
+    "ainative",
+    "openclaw",
+    "openclaw-ai",
+    "agent-swarm",
+    "zerolocal",
+    "claude",
+    "claude-code",
+    "claude-desktop",
+    "claude-ai-agents",
+    "codex",
+    "openai-agents",
+    "openai-codex",
+    "windsurf",
+    "cursor",
+    "cline",
+    "continue",
+    "vscode",
+    "langchain",
+    "crewai",
+    "autogen",
+    "n8n-ai",
+    "multi-agent",
+    "multi-agent-architecture",
+    "agent-orchestration",
+    "llm",
+    "ai",
+    "agentic-ai",
+    "ai-agents",
+    "ai-tool-calling",
+    "rag",
+    "retrieval-augmented-generation",
+    "local-first-ai"
+  ],
+  "author": {
+    "name": "AINative Studio",
+    "email": "toby@rely.ventures",
+    "url": "https://ainative.studio"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AINative-Studio/zerodb-sequential-thinking-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AINative-Studio/zerodb-sequential-thinking-mcp/issues"
+  },
+  "homepage": "https://github.com/AINative-Studio/zerodb-sequential-thinking-mcp#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "dotenv": "^16.4.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "src/",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/credentials.js

@@ -0,0 +1,40 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
+
+function credentialsDir() {
+  return process.env.ZERODB_CONFIG_DIR || join(homedir(), '.zerodb');
+}
+
+export function credentialsPath() {
+  return join(credentialsDir(), 'credentials.json');
+}
+
+export function readCredentials() {
+  try {
+    const raw = readFileSync(credentialsPath(), 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function writeCredentials(data) {
+  try {
+    const dir = credentialsDir();
+    mkdirSync(dir, { recursive: true });
+    const tmp = credentialsPath() + '.tmp';
+    writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf8');
+    renameSync(tmp, credentialsPath());
+  } catch (e) {
+    process.stderr.write(`[zerodb] Warning: could not write credentials: ${e.message}\n`);
+  }
+}
+
+export function markClaimed(newApiKey) {
+  const creds = readCredentials();
+  if (!creds) return;
+  creds.claimed = true;
+  if (newApiKey) creds.api_key = newApiKey;
+  writeCredentials(creds);
+}

package/src/plan-store.js

@@ -0,0 +1,57 @@
+// Persists concluded reasoning chains as ZeroDB plan artifacts.
+// Artifacts are keyed by artifact_id and can be resumed across sessions.
+
+const PLAN_API = '/api/v1/public/memory/v2/plan';
+
+export async function concludeChain(chainId, conclusion, title, type = 'plan', client) {
+  if (!client) {
+    return { artifact_id: null, conclusion, warning: 'No ZeroDB client — conclusion not persisted' };
+  }
+
+  const artifactTitle = title || conclusion.slice(0, 60);
+  const content = chainId
+    ? `## Conclusion\n${conclusion}\n\n## Chain ID\n${chainId}`
+    : `## Conclusion\n${conclusion}`;
+
+  try {
+    const artifact = await client.request('POST', `${PLAN_API}/`, {
+      title: artifactTitle,
+      type,
+      content,
+    });
+
+    return {
+      artifact_id: artifact.id,
+      title: artifact.title,
+      type: artifact.type,
+      status: artifact.status,
+      created_at: artifact.created_at,
+      resume_hint: `Use sequential_resume with artifact_id: "${artifact.id}" to continue this reasoning chain in a future session.`,
+    };
+  } catch (e) {
+    process.stderr.write(`[zerodb] Warning: failed to save plan artifact: ${e.message}\n`);
+    return { artifact_id: null, conclusion, error: e.message };
+  }
+}
+
+export async function resumeChain(artifactId, client) {
+  if (!client) {
+    return { error: 'No ZeroDB client — cannot resume' };
+  }
+
+  try {
+    const artifact = await client.request('GET', `${PLAN_API}/${artifactId}`);
+    return {
+      artifact_id: artifact.id,
+      title: artifact.title,
+      type: artifact.type,
+      status: artifact.status,
+      prior_content: artifact.content,
+      updated_at: artifact.updated_at,
+      resume_instruction: 'Prior reasoning chain loaded. Continue from the conclusion above.',
+    };
+  } catch (e) {
+    process.stderr.write(`[zerodb] Warning: failed to load plan artifact: ${e.message}\n`);
+    return { artifact_id: artifactId, error: e.message };
+  }
+}

package/src/provision.js

@@ -0,0 +1,112 @@
+// Auto-provisions a ZeroDB account on first run.
+// Full implementation: reads credentials, calls ZeroDB provisioning API,
+// writes credentials to ~/.zerodb-sequential-thinking-mcp.json.
+
+import { readCredentials, writeCredentials } from './credentials.js';
+
+const API_BASE = 'https://api.ainative.studio';
+
+export async function provision() {
+  // Power user override
+  if (process.env.ZERODB_API_KEY && process.env.ZERODB_PROJECT_ID) {
+    return {
+      api_key: process.env.ZERODB_API_KEY,
+      project_id: process.env.ZERODB_PROJECT_ID,
+      base_url: process.env.ZERODB_BASE_URL || API_BASE,
+      claimed: true,
+    };
+  }
+
+  const existing = readCredentials();
+  if (existing) {
+    const now = new Date();
+    const expires = existing.expires_at ? new Date(existing.expires_at) : null;
+
+    if (existing.claimed) return existing;
+
+    if (expires && expires <= now) {
+      process.stderr.write('[zerodb] Trial account expired — provisioning a new one...\n');
+      // fall through to re-provision
+    } else {
+      if (expires) {
+        const hoursLeft = Math.round((expires - now) / 3600000);
+        if (hoursLeft < 24) {
+          printExpiryWarning(existing.claim_url, hoursLeft);
+        }
+      }
+      return existing;
+    }
+  }
+
+  // Provision new account
+  const creds = await createInstantDB();
+  writeCredentials(creds);
+  printFirstRunBanner(creds.claim_url, creds.api_key);
+
+  // Soft email capture
+  if (process.env.ZERODB_EMAIL) {
+    await sendClaimEmail(process.env.ZERODB_EMAIL, creds.claim_url, creds.project_id, creds.api_key).catch(() => {});
+  }
+
+  return creds;
+}
+
+async function createInstantDB() {
+  const res = await fetch(`${API_BASE}/api/v1/instant-db`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ agree_terms: true, on_behalf_of: 'mcp-sequential-thinking' }),
+    signal: AbortSignal.timeout(15000),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`ZeroDB provisioning failed (${res.status}): ${text}`);
+  }
+
+  const data = await res.json();
+  return {
+    api_key: data.api_key,
+    project_id: data.project_id,
+    base_url: API_BASE,
+    expires_at: data.expires_at,
+    claim_url: data.claim_url,
+    claimed: false,
+  };
+}
+
+async function sendClaimEmail(email, claimUrl, projectId, apiKey) {
+  await fetch(`${API_BASE}/api/v1/instant-db/send-claim-email`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-API-Key': apiKey },
+    body: JSON.stringify({ email, claim_url: claimUrl, project_id: projectId }),
+    signal: AbortSignal.timeout(10000),
+  });
+}
+
+function printFirstRunBanner(claimUrl, apiKey) {
+  const key = apiKey ? apiKey.slice(0, 12) + '...' : '(see credentials file)';
+  process.stderr.write(`
+┌─────────────────────────────────────────────────────────────┐
+│  ZeroDB account provisioned (72h trial)                     │
+│                                                             │
+│  Your reasoning chains are now persisted in ZeroDB.         │
+│  API key: ${key.padEnd(49)}│
+│                                                             │
+│  Claim your account to keep data permanently:               │
+│  → ${(claimUrl || '').slice(0, 55).padEnd(55)}│
+│                                                             │
+│  Optional: set ZERODB_EMAIL=you@email.com in your MCP       │
+│  config to receive account details via email.               │
+│                                                             │
+│  This message won't appear again after you claim.           │
+└─────────────────────────────────────────────────────────────┘
+`);
+}
+
+function printExpiryWarning(claimUrl, hoursLeft) {
+  process.stderr.write(`
+[zerodb] ⚠️  Your ZeroDB trial expires in ${hoursLeft}h.
+[zerodb] Claim now to keep your reasoning history: ${claimUrl}
+`);
+}

package/src/reasoner.js

@@ -0,0 +1,56 @@
+import { randomUUID } from 'crypto';
+
+// In-memory chain store for the current session
+const chains = new Map();
+
+export function getOrCreateChain(chainId) {
+  if (!chainId) chainId = randomUUID();
+  if (!chains.has(chainId)) {
+    chains.set(chainId, { chainId, steps: [], createdAt: new Date().toISOString() });
+  }
+  return chains.get(chainId);
+}
+
+export async function addStep(args, client) {
+  const { thought, chain_id, step_number, total_steps, next_step, is_final = false, persist_steps = false } = args;
+  const chain = getOrCreateChain(chain_id);
+
+  const step = {
+    step: step_number || chain.steps.length + 1,
+    thought,
+    next_step: next_step || null,
+    is_final,
+    timestamp: new Date().toISOString(),
+  };
+
+  chain.steps.push(step);
+
+  // Optional ZeroDB persistence
+  if (persist_steps && client) {
+    try {
+      await client.request('POST', '/api/v1/public/memory/v2/remember', {
+        content: `[Step ${step.step}] ${thought}`,
+        entity_id: chain.chainId,
+        memory_type: 'working',
+        importance: 0.6,
+        tags: ['sequential-thinking', `chain-${chain.chainId}`],
+      });
+    } catch (e) {
+      process.stderr.write(`[zerodb] Warning: failed to persist step: ${e.message}\n`);
+    }
+  }
+
+  return {
+    chain_id: chain.chainId,
+    step: step.step,
+    total_steps: total_steps || '?',
+    thought,
+    next_step,
+    is_final,
+    steps_so_far: chain.steps.length,
+  };
+}
+
+export function getChain(chainId) {
+  return chains.get(chainId) || null;
+}

package/src/tools.js

@@ -0,0 +1,63 @@
+import { addStep, getChain } from './reasoner.js';
+import { concludeChain, resumeChain } from './plan-store.js';
+
+export const TOOLS = [
+  {
+    name: 'sequential_think',
+    description: 'Perform a sequential reasoning step. Chain multiple calls for complex problems. Optionally persist steps to ZeroDB for cross-session continuity.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        thought: { type: 'string', description: 'The current reasoning step' },
+        chain_id: { type: 'string', description: 'Chain ID (auto-generated on first call)' },
+        step_number: { type: 'number', description: 'Current step number' },
+        total_steps: { type: 'number', description: 'Estimated total steps' },
+        next_step: { type: 'string', description: 'What to reason about next' },
+        is_final: { type: 'boolean', description: 'Is this the last step before concluding?', default: false },
+        persist_steps: { type: 'boolean', description: 'Persist each step to ZeroDB working memory', default: false }
+      },
+      required: ['thought']
+    }
+  },
+  {
+    name: 'sequential_conclude',
+    description: 'Finalize a reasoning chain and save the conclusion as a persistent ZeroDB plan artifact. Returns an artifact_id you can use to resume in future sessions.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        chain_id: { type: 'string', description: 'Chain ID from sequential_think calls' },
+        conclusion: { type: 'string', description: 'The final answer or decision' },
+        title: { type: 'string', description: 'Artifact title (defaults to first 60 chars of conclusion)' },
+        save_as: { type: 'string', enum: ['plan', 'prd', 'task'], default: 'plan', description: 'Artifact type' }
+      },
+      required: ['conclusion']
+    }
+  },
+  {
+    name: 'sequential_resume',
+    description: 'Resume a reasoning chain from a previous session using an artifact_id returned by sequential_conclude.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        artifact_id: { type: 'string', description: 'Artifact ID from a prior sequential_conclude call' }
+      },
+      required: ['artifact_id']
+    }
+  }
+];
+
+export async function executeTool(name, args, client) {
+  switch (name) {
+    case 'sequential_think':
+      return addStep(args, client);
+
+    case 'sequential_conclude':
+      return concludeChain(args.chain_id, args.conclusion, args.title, args.save_as || 'plan', client);
+
+    case 'sequential_resume':
+      return resumeChain(args.artifact_id, client);
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}

package/src/zerodb.js

@@ -0,0 +1,37 @@
+// Thin HTTP client for the ZeroDB / AINative API.
+
+export class ZeroDBClient {
+  constructor({ api_key, project_id, base_url = 'https://api.ainative.studio' }) {
+    this.apiKey = api_key;
+    this.projectId = project_id;
+    this.baseUrl = base_url;
+  }
+
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const opts = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-API-Key': this.apiKey,
+      },
+      signal: AbortSignal.timeout(10000),
+    };
+    if (body && method !== 'GET') opts.body = JSON.stringify(body);
+
+    const res = await fetch(url, opts);
+
+    if (res.status === 401) {
+      process.stderr.write('[zerodb] 401 Unauthorized — your API key may have expired. Re-run to re-provision or set ZERODB_API_KEY.\n');
+    }
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`ZeroDB API error ${res.status} ${method} ${path}: ${text}`);
+    }
+
+    const ct = res.headers.get('content-type') || '';
+    if (ct.includes('application/json')) return res.json();
+    return res.text();
+  }
+}