cordn8 1.14.5 → 1.15.0

package/README.md

@@ -1,184 +1,168 @@
-# Cordn8
+<p align="center">
+  <img src="apps/web/public/cordn8-logo.png" alt="Cordn8 logo" width="160" height="160" />
+</p>
 
-**The local-first coordination layer for AI agents.** One auditable channel for every Claude, GPT, Hermes, NVIDIA NIM, or local Llama you've wired in. Append-only, grep-able, git-visible. Works without us — your data never leaves disk.
+<h1 align="center">Cordn8</h1>
+
+**The local-first coordination protocol for AI agents.** One auditable, append-only channel for every Claude, GPT, Hermes, NVIDIA NIM, Ollama, or custom assistant working in your repository. Git-visible, grep-able, and entirely secure — your data never leaves your disk.
 
 [![CI](https://github.com/MorvaniLabs/cordn8/actions/workflows/ci.yml/badge.svg)](https://github.com/MorvaniLabs/cordn8/actions/workflows/ci.yml) [![Release](https://github.com/MorvaniLabs/cordn8/actions/workflows/release.yml/badge.svg)](https://github.com/MorvaniLabs/cordn8/actions/workflows/release.yml) [![npm version](https://img.shields.io/npm/v/cordn8.svg)](https://www.npmjs.com/package/cordn8) [![Node](https://img.shields.io/badge/node-%E2%89%A518-339933?logo=node.js&logoColor=white)](https://nodejs.org) [![TypeScript](https://img.shields.io/badge/TypeScript-5%2B-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org/) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE) [![Release](https://img.shields.io/badge/release-v1.14.5-ec4899)](CHANGELOG.md)
 
 ![Cordn8 Orchestration Hub — V1.14.5 dashboard with one-click dispatch, Maya release gate, audit panel, and per-agent activity](apps/web/public/dashboard-hero.png)
 
-## What Cordn8 actually does for you
+---
+
+## What Cordn8 Does for Your Multi-Agent Workflows
 
-| Outcome | How | Verify |
+| Outcome | How It Works | Verification Command |
 | --- | --- | --- |
-| **Every agent action is on disk, in markdown** | One append-only channel per repo (`docs/agent-channel.md`) | `cat docs/agent-channel.md` |
-| **Approval routing without writing a workflow engine** | 3 operational modes (MANUAL / COPILOT / AUTOPILOT) with per-criticality overrides | `cordn8 mode get` |
-| **Release gate that catches agent regressions before merge** | Maya — 22 journeys + 10 gates, auto-runs against your repo | `cordn8 maya` |
-| **Mix Claude, GPT, Hermes, Ollama, Groq on the same task** | Universal Adapter Surface — same dispatch, any agent | `cordn8 install --list` |
-| **Dispatch by describing the goal, not memorizing flags** | Intent Engine — natural-language `do --ai` / `ask` with risk + friction scoring | `cordn8 ask "who's idle?"` |
-| **Ground agent work in trusted sources + locked decisions** | Context Spine — Source Vault, Decision Ledger, Mission Brief, Evidence-Lite gating | `cordn8 sources list` |
-| **Prove a deliverable is launch-ready, not just that it built** | Maya Launch-Readiness — pluggable evidence sources → PASS/WARN/FAIL + auto-tasks | `cordn8 maya launch-check` |
-| **Quantified ROI** — see what coordination is actually saving you | Per-agent dispatch volume, approvals routed, stale entries triaged | `cordn8 stats` |
-| **You can walk away with everything** | Plain markdown + JSON + ndjson export with SHA-256 manifest | `cordn8 export-all` |
+| **Complete local auditability** | One append-only Markdown channel (`docs/agent-channel.md`) tracks all dispatches, handoffs, and approvals inline. | `cat docs/agent-channel.md` |
+| **Resilient Loop-Free Onboarding** | Auto-detects local runtimes (like Ollama and Homebrew) and uses an inquirer-hardened picker with zero-key preset fallbacks. | `cordn8 start` |
+| **Zero-friction autonomy controls** | Three explicit modes (MANUAL / COPILOT / AUTOPILOT) let you dial agent autonomy up or down without rewriting code. | `cordn8 mode get` |
+| **Continuous Maya validation** | The built-in decision engine executes 22 validation journeys and 10 structural gates to inspect your project dynamically. | `cordn8 maya` |
+| **Context Spine grounding** | Grounds agent dispatches in locked Briefs, evolutionary Source Vaults, and locked Decision Ledgers. | `cordn8 sources list` |
+| **The Cordn8 Mantle Dashboard** | A gorgeous local Next.js GUI providing cost, latency, and trust scoring with real-time route triaging. | `cordn8 dashboard` |
+| **Universal Adapter Edge** | A unified contract allowing dispatches to Anthropic Messages, OpenAI, Groq, Ollama, Hermes, or custom tools. | `cordn8 install --list` |
+| **Multi-Agent CI/CD Collaboration** | Concurrency-safe lock writers and secure ship gates allow authorized AI assistants to commit and push safely. | `cordn8 ship` |
 
-## Use Cordn8 when…
+---
 
-- You have **2+ AI agents** working on the same repo and need them not to step on each other
-- You need an **audit trail of every agent decision** that a compliance reviewer can actually read
-- You want to **swap model providers** without rewriting your coordination glue
-- You're **shipping AI code to production** and need a release gate
-- Your security review **won't approve a hosted vendor** — local-first is non-negotiable
+## When to Use Cordn8
 
-**Don't use Cordn8 when:** You have one agent in one IDE, you need a hosted SaaS with no install step, or your team won't tolerate any CLI surface. (Cursor + Claude Code's built-in `/agents` is a better fit there.)
+- **Multi-Agent Repositories**: You have 2+ AI assistants working in the same codebase and need to prevent overlapping edits, state drift, and merge conflicts.
+- **Strict Compliance & Audits**: You need a persistent, human-readable audit trail of every AI decision checked directly into git.
+- **Provider Portability**: You want to swap models (e.g., Anthropic Claude for local Llama via Ollama) without modifying your orchestration code.
+- **Continuous Integration Gates**: You want to block builds on agent regressions, uninitialized configurations, or missing source grounding before staging.
+- **Air-Gapped & Secure Environments**: Your security policy prohibits hosted SaaS wrappers. Cordn8 is local-first, storing telemetry on SQLite and channels on markdown.
 
-Cordn8 installs into a repository and creates a shared append-only channel. Humans and agents use that channel to dispatch work, request approvals, post handoffs, report blockers, and leave a git-visible audit trail. The platform is not tied to one model provider or one agent brand: any agent can participate via a Cordn8 adapter, inbox workflow, CLI bridge, API bridge, or IDE integration.
+**When NOT to use Cordn8:** You are running a single agent inside an IDE (e.g., Cursor or standard Claude Code), you prefer a hosted SaaS control plane with zero local setup, or your team does not work with command-line tools.
 
-> **Read the [Manifesto](MANIFESTO.md)** for the product philosophy and the distinction between Cordn8 and code-first orchestration frameworks.
-> **Read [PRICING.md](PRICING.md)** for what's free forever vs. what's coming in Cordn8 Pro.
+---
 
-## Install
+## Install & Setup
 
 ```bash
 # Global install from npm (recommended)
 npm install -g cordn8
 
-# Or try without installing
+# Or try immediately without installing
 npx cordn8 start
 ```
 
-**Build from source:**
-
+### Build from Source
 ```bash
-git clone https://github.com/MorvaniLabs/cordn8.git
+git clone git@github.com:MorvaniLabs/cordn8.git
 cd cordn8
 npm install
-npm run build
-node bin/cordn8 --version
+npm run build:all
+node dist/cli.js --version
 ```
+*Requires Node.js 18+ and npm.*
 
-Requires Node.js 18+.
+---
 
-## Quick Start
+## Quick Start CLI Journey
+
+Scaffold your workspace, configure your first agent, and tail the append-only log in six commands:
 
 ```bash
-# 1. Initialize Cordn8 in your repo (creates the channel + config)
+# 1. Initialize Cordn8 in your workspace
 cordn8 init
 
-# 2. Watch the channel for live dispatch / approvals
+# 2. Add your first local or cloud model provider
+cordn8 install nvidia-nim
+
+# 3. Start the local dispatch and watcher daemon
 cordn8 watch
 
-# 3. Open the operator landing view
-cordn8 home
-```
+# 4. Dispatch a task with automatic agent selection
+cordn8 do "build user login endpoint"
 
-From there:
+# 5. Tail the live append-only coordination channel
+cordn8 channel tail --follow
 
-```bash
-cordn8 start              # interactive onboarding: plan + pick agent + first dispatch
-cordn8 do "build login"   # dispatch a task with auto agent selection
-cordn8 show               # lanes + open tasks + recent activity + Maya gate
-cordn8 fix                # doctor + Maya gate + one-line next action
-cordn8 ship               # deploy walkthrough
+# 6. Audit project health and validation scorecard
+cordn8 maya
 ```
 
-For the full walkthrough, see the [Quickstart Guide](docs/quickstart.md).
+---
 
-## Web Dashboard
+## The Cordn8 Mantle Web Dashboard
 
-Cordn8 ships a local Next.js dashboard — the **Cordn8 Mantle** — for operators who prefer a GUI.
+Cordn8 ships with a built-in local Next.js GUI — the **Cordn8 Mantle** — for operators who prefer visual management.
 
 ```bash
-cordn8 dashboard          # starts the local dashboard and opens it in your browser
+cordn8 dashboard
 ```
+*This starts a local dashboard server and automatically opens it in your web browser. No hosted cloud endpoints required.*
 
-The dashboard shows:
-
-- **One-click dispatch** to any installed agent
-- **Maya release gate** with per-failure remediation
-- **Per-agent activity** with cost, latency, and trust scoring
-- **Channel view** with grep, tail, and digest collapse
-- **Audit panel** for approvals, denials, and handoffs
+The Mantle dashboard provides:
+* **One-Click Dispatch**: Drag and drop tasks and assign them instantly.
+* **Interactive Maya Scorecard**: Deep-dive into validation failures with one-click remediation.
+* **Telemetry Insights**: Real-time graphs showing cumulative cost, token latency, and agent trust bands.
+* **Channel Reader**: A gorgeous, collapsed grid of the markdown log featuring inline grep and tail filters.
 
-The CLI and dashboard read the same local state — switch freely between them.
+---
 
-## Key Command Groups
+## CLI Command Registry
 
-The CLI surfaces ~240 commands; the groups below cover most day-to-day work. Run `cordn8 --help` for the full list or `cordn8 help --all` for the expert tree.
+The Cordn8 CLI exposes ~240 commands categorized into logical groups. Run `cordn8 --help` for usage details on any command:
 
-| Group | What it does | Examples |
+| Command Group | Focus Area | Essential Commands |
 | --- | --- | --- |
-| **Lifecycle** | Bootstrap, watch, doctor, deploy | `init`, `watch`, `doctor`, `ship`, `preview` |
-| **Dispatch** | Send work, approve, deny, inspect tasks | `do`, `do --ai`, `ask`, `send`, `dispatch`, `approve`, `deny`, `task show` |
-| **Channel** | Inspect + broadcast on the append-only log | `channel tail`, `channel grep`, `channel digest`, `channel broadcast`, `channel restore` |
-| **Context Spine** | Ground work in trusted sources + decisions | `sources add\|list`, `decisions add\|lock`, `brief mission` |
-| **Agents** | Install, configure, score, inspect | `install`, `agent show`, `agent capabilities`, `lane`, `ownership` |
-| **Adapters** | Manage provider integrations | `adapter list`, `adapters`, `install <provider>` |
-| **Modes** | Switch autonomy level | `mode get`, `mode set MANUAL\|COPILOT\|AUTOPILOT`, `mode optimizations` |
-| **MCP** | Manage Model Context Protocol servers | `mcp enable`, `mcp disable`, `mcp status` |
-| **Cost & Budget** | Track spend, set caps | `cost`, `budget set`, `budget status` |
-| **Memory & Insights** | Operational intelligence graph | `memory show`, `insights export`, `insights-config` |
-| **Maya & QC** | Release gates + launch-readiness evidence | `maya`, `maya launch-check`, `maya --fix-plan`, `qc`, `doctor --explain` |
-| **Steward** | Artifact lifecycle (score, transition, archive) | `steward run` |
-| **Diagnostics** | Triage and support | `why <msg_id>`, `error <code>`, `export <bundle>`, `friction "..."` |
-
-## Agent Modes
-
-Cordn8 gives operators three levers for how much autonomy agents have:
-
-- **`MANUAL`** — every dispatch needs an explicit human approval before the agent acts. Safest; highest friction.
-- **`COPILOT`** — agents propose work and can act on low-risk steps; risky steps still require approval.
-- **`AUTOPILOT`** — agents execute end-to-end within their declared sandbox and budget; the channel records everything for after-the-fact review.
-
-Switch modes any time with `cordn8 mode set <MODE>`. Mode changes are written to the channel, so the audit trail always reflects what level of autonomy was in effect when a decision was made.
-
-## Adapter Model
-
-Cordn8's core stays local-first. Network calls happen at the adapter edge after an operator configures a provider or agent.
-
-Current built-in and documented paths include:
-
-- **Hermes** — local CLI integration
-- **NVIDIA NIM** — cloud API integration and a low-friction first real agent
-- **Anthropic** — Claude via the Messages API
-- **OpenAI** — chat-completions adapter
-- **Groq** — fast hosted inference (OpenAI-compatible)
-- **Ollama** — fully local models, no API key
-- **OpenRouter** — single key, many hosted models
-- **Antigravity** — IDE-assisted workflow using Cordn8 skills and inbox routing
-- **Mock / local stub** — offline development, CI, and smoke-test paths
-- **Custom adapters** — adapter contract, plugin guidance, and conformance testing
-
-See [Adapter Docs](docs/adapters/README.md) and [Write Your Own Adapter](docs/adapters/write-your-own.md).
-
-## How Cordn8 Differs
-
-**Cordn8 is repo-and-channel-centered, not platform-centered.** It does not require teams to move work into a hosted orchestration platform or rewrite workflows around a single model provider. The coordination state lives in your project, the audit trail is visible in normal developer tools, and cloud services are optional adapter choices.
-
-LangGraph and AutoGen are code-first orchestration frameworks. CrewAI focuses on persona-style crews. Hosted dashboards centralize workflow state outside the repository. Cordn8 is designed for operators who want multiple AI agents in the loop while keeping the coordination record local, reviewable, and portable.
-
-See [Competitive Positioning](docs/strategy/competitive-positioning.md) for the longer comparison.
-
-## Architecture
+| **Lifecycle** | Scaffolding, watch daemons, health audits, deploys | `init`, `watch`, `doctor`, `ship`, `preview` |
+| **Dispatch** | Goal wizardry, approvals, task lifecycles | `do`, `do --ai`, `ask`, `send`, `approve`, `deny`, `task show` |
+| **Channel** | Tail log, grep filters, snapshots, recovery | `channel tail`, `channel grep`, `channel digest`, `channel restore` |
+| **Spine** | Source vaults, decision ledgers, brief locks | `sources add`, `sources list`, `decisions lock`, `brief mission` |
+| **Agents** | Capabilities, role management, lanes, ownerships | `install`, `agent show`, `agent capabilities`, `lane`, `ownership` |
+| **Modes** | Autonomy control & optimizations | `mode get`, `mode set MANUAL\|COPILOT\|AUTOPILOT` |
+| **MCP** | Model Context Protocol servers | `mcp enable`, `mcp disable`, `mcp status` |
+| **Cost & Budget** | Financial guardrails & spending caps | `cost`, `budget set`, `budget status` |
+| **Diagnostics** | Message tracing, error definitions, friction logs | `why <msg_id>`, `error <code>`, `export <bundle>`, `friction` |
+
+---
+
+## Autonomy Modes
+
+Coordinate the balance of human supervision versus agent velocity with three simple modes:
+
+1. **`MANUAL`**: High-security, high-supervision. Every agent action requires explicit human approval before execution.
+2. **`COPILOT`**: High-velocity collaboration. Agents execute routine, low-risk steps automatically, while high-risk changes (like filesystem writes) queue for approval.
+3. **`AUTOPILOT`**: Maximum velocity. Agents execute end-to-end within their sandbox boundaries and token budgets, appending details to the channel for post-hoc audits.
+
+Modes can be set dynamically via `cordn8 mode set <MODE>`. Changes are committed directly to the channel, ensuring the audit history records the exact level of autonomy active at the moment of every AI decision.
+
+---
+
+## Architecture Blueprint
+
+```mermaid
+graph TD
+    User([Operator CLI / GUI]) --> |Dispatches Goal| Engine[Intent Engine]
+    Engine --> |Builds Brief| Spine[Context Spine]
+    Spine --> |Grounds Sources| Vault[(Source Vault & Decision Ledger)]
+    Spine --> |Appends inline| Channel[safe-write docs/agent-channel.md]
+    Channel --> |Triggers Watcher| Daemon[Watch Daemon]
+    Daemon --> |Dispatches to| Edge[Universal Edge Adapters]
+    Edge --> |Claude / GPT / NIM / Ollama| AI[AI Agent Sandbox]
+    AI --> |Commits proposal| Channel
+    Daemon --> |Runs validation| Maya[Maya Decision Engine]
+    Maya --> |Scorecard PASS/FAIL| User
+```
 
-- **Core** — TypeScript CLI and local coordination layer for Node.js 18+
-- **Channel** — append-only markdown with a safe writer, validation, snapshots, and restore
-- **Telemetry** — local SQLite-backed event and read-model storage
-- **Adapters** — provider, CLI, IDE, and custom integration boundary
-- **Dashboard** — local Next.js interface launched with `cordn8 dashboard`
-- **Optional desktop shell** — Tauri wrapper for native app packaging; the CLI does not require Rust
+---
 
-## Documentation
+## Documentation Index
 
-Deeper docs live under [`docs/`](docs/):
+Detailed guides are located in the [`docs/`](docs/) directory:
+* [Quickstart Guide](docs/quickstart.md) — Walkthrough of your first 15 minutes.
+* [Operator Guide](docs/operator-guide.md) — Comprehensive guide on modes, budgets, and the Context Spine.
+* [CLI Cheatsheet](docs/CHEATSHEET.md) — One-page quick reference.
+* [Adapter Integration](docs/adapters/README.md) — How to wire up Ollama, Anthropic, OpenAI, or write your own.
+* [FAQ & Troubleshooting](docs/FAQ.md) — Common questions and operational support.
 
-- [Quickstart Guide](docs/quickstart.md)
-- [Operator Guide](docs/operator-guide.md)
-- [CLI Cheatsheet](docs/CHEATSHEET.md)
-- [Architecture Overview](docs/architecture/overview.md)
-- [Adapter Docs](docs/adapters/README.md)
-- [FAQ](docs/FAQ.md) · [Glossary](docs/GLOSSARY.md) · [Troubleshooting](docs/troubleshooting.md)
-- [Manifesto](MANIFESTO.md) · [Security Policy](SECURITY.md) · [Contributing](docs/CONTRIBUTING.md)
-- [Changelog](CHANGELOG.md)
+---
 
 ## License
 
-Cordn8 is released under the [MIT License](LICENSE).
+Cordn8 is open source software released under the [MIT License](LICENSE).

package/dist/agents/adapters/claude.d.ts

@@ -0,0 +1,3 @@
+import { AgentAdapter } from '../adapter';
+export declare const ClaudeAdapter: AgentAdapter;
+//# sourceMappingURL=claude.d.ts.map

package/dist/agents/adapters/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/claude.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAyB1C,eAAO,MAAM,aAAa,EAAE,YAyE3B,CAAC"}

package/dist/agents/adapters/claude.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAdapter = void 0;
+const llm_1 = require("../build/llm");
+const run_builder_1 = require("../build/run-builder");
+const credentials_1 = require("../../storage/credentials");
+const ANTHROPIC_KEY_ENV = 'ANTHROPIC_API_KEY';
+const DEFAULT_MODEL = 'claude-sonnet-4-6';
+/**
+ * Resolve the Anthropic API key without ever logging it. Prefer the OS
+ * keychain (cordn8 credential store, keyed by 'claude') so the key is never in
+ * plaintext on disk; fall back to the ANTHROPIC_API_KEY env var for CI / quick
+ * runs. Returns null when neither is present.
+ */
+async function resolveApiKey() {
+    try {
+        const stored = await (0, credentials_1.getSecret)('claude');
+        if (stored)
+            return stored;
+    }
+    catch {
+        /* keychain unavailable → fall back to env */
+    }
+    return process.env[ANTHROPIC_KEY_ENV] || null;
+}
+exports.ClaudeAdapter = {
+    id: 'claude',
+    type: 'API',
+    displayName: 'Claude (Anthropic API)',
+    async detect() {
+        return Boolean(await resolveApiKey());
+    },
+    async register(projectRoot, options) {
+        const model = options?.model || process.env.CORDN8_CLAUDE_MODEL || DEFAULT_MODEL;
+        return {
+            id: `claude-${model}`,
+            name: `Claude-${model}`,
+            adapter_id: 'claude',
+            role: 'BUILDER',
+            is_active: true,
+            added_at: new Date().toISOString(),
+            config: {
+                endpoint: 'https://api.anthropic.com/v1/messages',
+                default_model: model,
+                auth_env_var: ANTHROPIC_KEY_ENV,
+            },
+        };
+    },
+    async generateIntegrationArtifacts() {
+        return { files: [] };
+    },
+    /**
+     * Real build via the Anthropic API, through the shared build → verify → retry
+     * → write pipeline (run-builder.ts). The API key is read from the environment
+     * (ANTHROPIC_API_KEY) and never logged or persisted. Decomposition + the
+     * post-build verifier apply exactly as they do for the local builder, so a
+     * stronger model raises per-file quality without changing the contract.
+     */
+    async onMessageHook(msg, recipient) {
+        // Skip only our own TERMINAL replies (RESOLVED/BLOCKED). A single-agent
+        // setup self-dispatches (FROM==TO) with STATUS: PENDING — that's real work
+        // and must be built, so a blanket `from === recipient` skip is wrong here.
+        const task = (msg.content || '').trim();
+        const status = String(msg.status || '').toUpperCase();
+        const isOwnReply = msg.from === recipient && (status === 'RESOLVED' || status === 'BLOCKED');
+        if (!task || isOwnReply)
+            return;
+        const apiKey = await resolveApiKey();
+        if (!apiKey) {
+            // No key → fail honestly rather than silently doing nothing.
+            const { writeMessage } = await Promise.resolve().then(() => __importStar(require('../../channel/writer')));
+            const channelPath = process.env.CORDN8_CHANNEL_PATH;
+            if (channelPath) {
+                await writeMessage(channelPath, {
+                    from: recipient || 'Claude',
+                    to: msg.from,
+                    task_ref: msg.task_ref,
+                    content: `Cannot build: no Anthropic API key found. Set ${ANTHROPIC_KEY_ENV} in the watcher's environment (export ${ANTHROPIC_KEY_ENV}=sk-ant-... before "cordn8 watch") and re-dispatch.`,
+                }, { mode: 'MANUAL', projectRoot: process.env.CORDN8_PROJECT_ROOT, status_override: 'BLOCKED' });
+            }
+            return;
+        }
+        const model = process.env.CORDN8_CLAUDE_MODEL || DEFAULT_MODEL;
+        await (0, run_builder_1.runBuilderHook)(msg, recipient, {
+            agentName: 'Claude',
+            complete: (0, llm_1.anthropicCompletion)({ apiKey, model }),
+            model,
+        });
+    },
+};
+//# sourceMappingURL=claude.js.map

package/dist/agents/adapters/claude.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.js","sourceRoot":"","sources":["../../../src/agents/adapters/claude.ts"],"names":[],"mappings":"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"}

package/dist/agents/adapters/ollama.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/ollama.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1C,eAAO,MAAM,aAAa,EAAE,YAkC3B,CAAC"}
+{"version":3,"file":"ollama.d.ts","sourceRoot":"","sources":["../../../src/agents/adapters/ollama.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAK1C,eAAO,MAAM,aAAa,EAAE,YAoD3B,CAAC"}

package/dist/agents/adapters/ollama.js

@@ -1,15 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OllamaAdapter = void 0;
+const llm_1 = require("../build/llm");
+const run_builder_1 = require("../build/run-builder");
 exports.OllamaAdapter = {
     id: 'ollama',
     type: 'OLLAMA',
     displayName: 'Ollama Local',
-    async detect(projectRoot) {
-        return true; // Always assume reachable, relies on localhost
+    async detect() {
+        // Reachable iff the local Ollama server answers.
+        try {
+            const res = await fetch('http://localhost:11434/api/tags', {
+                signal: AbortSignal.timeout(3000),
+            });
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
     },
     async register(projectRoot, options) {
-        const model = options?.model || 'llama3';
+        const model = options?.model || 'qwen2.5-coder:7b';
         return {
             id: `ollama-${model}`,
             name: `Ollama-${model}`,
@@ -24,12 +35,22 @@ exports.OllamaAdapter = {
             },
         };
     },
-    async generateIntegrationArtifacts(projectRoot) {
+    async generateIntegrationArtifacts() {
         return { files: [] };
     },
+    /**
+     * Real build: turn the dispatched task into files via the local model, using
+     * the shared build → verify → retry → write pipeline (run-builder.ts). The
+     * only Ollama-specific part is the completion backend.
+     */
     async onMessageHook(msg, recipient) {
-        // Scaffold: to be implemented
-        throw new Error('Ollama integration not fully implemented.');
-    }
+        const model = process.env.CORDN8_OLLAMA_MODEL || 'qwen2.5-coder:7b';
+        const endpoint = process.env.CORDN8_OLLAMA_ENDPOINT || 'http://localhost:11434/api/generate';
+        await (0, run_builder_1.runBuilderHook)(msg, recipient, {
+            agentName: 'Ollama',
+            complete: (0, llm_1.ollamaCompletion)({ endpoint, model }),
+            model,
+        });
+    },
 };
 //# sourceMappingURL=ollama.js.map

package/dist/agents/adapters/ollama.js.map

@@ -1 +1 @@
-{"version":3,"file":"ollama.js","sourceRoot":"","sources":["../../../src/agents/adapters/ollama.ts"],"names":[],"mappings":";;;AAGa,QAAA,aAAa,GAAiB;IACzC,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,cAAc;IAE3B,KAAK,CAAC,MAAM,CAAC,WAAmB;QAC9B,OAAO,IAAI,CAAC,CAAC,+CAA+C;IAC9D,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,WAAmB,EAAE,OAAa;QAC/C,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,QAAQ,CAAC;QACzC,OAAO;YACL,EAAE,EAAE,UAAU,KAAK,EAAE;YACrB,IAAI,EAAE,UAAU,KAAK,EAAE;YACvB,UAAU,EAAE,QAAQ;YACpB,IAAI,EAAE,SAAS;YACf,SAAS,EAAE,IAAI;YACf,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YAClC,MAAM,EAAE;gBACN,QAAQ,EAAE,qCAAqC;gBAC/C,aAAa,EAAE,KAAK;gBACpB,YAAY,EAAE,IAAI;aACnB;SACF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,4BAA4B,CAAC,WAAmB;QACpD,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,GAAY,EAAE,SAAkB;QAClD,8BAA8B;QAC9B,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;IAC/D,CAAC;CACF,CAAC"}
+{"version":3,"file":"ollama.js","sourceRoot":"","sources":["../../../src/agents/adapters/ollama.ts"],"names":[],"mappings":";;;AAEA,sCAAgD;AAChD,sDAAsD;AAEzC,QAAA,aAAa,GAAiB;IACzC,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,cAAc;IAE3B,KAAK,CAAC,MAAM;QACV,iDAAiD;QACjD,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,iCAAiC,EAAE;gBACzD,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC;aAClC,CAAC,CAAC;YACH,OAAO,GAAG,CAAC,EAAE,CAAC;QAChB,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,KAAK,CAAC,QAAQ,CAAC,WAAmB,EAAE,OAA4B;QAC9D,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,kBAAkB,CAAC;QACnD,OAAO;YACL,EAAE,EAAE,UAAU,KAAK,EAAE;YACrB,IAAI,EAAE,UAAU,KAAK,EAAE;YACvB,UAAU,EAAE,QAAQ;YACpB,IAAI,EAAE,SAAS;YACf,SAAS,EAAE,IAAI;YACf,QAAQ,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YAClC,MAAM,EAAE;gBACN,QAAQ,EAAE,qCAAqC;gBAC/C,aAAa,EAAE,KAAK;gBACpB,YAAY,EAAE,IAAI;aACnB;SACF,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,4BAA4B;QAChC,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,aAAa,CAAC,GAAY,EAAE,SAAkB;QAClD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,IAAI,kBAAkB,CAAC;QACpE,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,sBAAsB,IAAI,qCAAqC,CAAC;QAC7F,MAAM,IAAA,4BAAc,EAAC,GAAG,EAAE,SAAS,EAAE;YACnC,SAAS,EAAE,QAAQ;YACnB,QAAQ,EAAE,IAAA,sBAAgB,EAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;YAC/C,KAAK;SACN,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/agents/build/file-blocks.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Parse LLM build output into a set of files to write.
+ *
+ * The build contract with the model is a fenced code block whose info-string
+ * names the target path, e.g.:
+ *
+ *   ```file:src/index.html
+ *   <!doctype html>...
+ *   ```
+ *
+ * We also accept a few formats that local models commonly drift into:
+ *   ```file: index.html        (space after colon)
+ *   ```path=index.html
+ *   ```html index.html         (lang then path)
+ *
+ * This module is deliberately pure (string in, structured out) so it can be
+ * unit-tested without any model, filesystem, or network.
+ */
+export interface ParsedFile {
+    path: string;
+    content: string;
+}
+/** A path is acceptable if it's a relative, non-escaping POSIX-ish path. */
+export declare function isSafeRelativePath(p: string): boolean;
+/** Extract a target path from a fence info-string, or null if none. */
+export declare function pathFromInfoString(info: string): string | null;
+/**
+ * Parse all fenced code blocks that declare a file path.
+ * Returns one ParsedFile per safe, path-bearing block.
+ */
+export declare function parseFileBlocks(text: string): ParsedFile[];
+//# sourceMappingURL=file-blocks.d.ts.map

package/dist/agents/build/file-blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-blocks.d.ts","sourceRoot":"","sources":["../../../src/agents/build/file-blocks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,4EAA4E;AAC5E,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CASrD;AAED,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAoB9D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CAiB1D"}