hermes-taskflow 0.2.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 heggria
+
+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,447 @@
+<div align="center">
+
+<img src="https://raw.githubusercontent.com/heggria/taskflow/main/assets/hero.png" alt="taskflow: compile, verify, and run multi-agent DAGs across six coding-agent hosts" width="100%">
+
+<br />
+
+[![npm](https://img.shields.io/npm/v/pi-taskflow?style=flat-square&color=7775FF&label=npm)](https://www.npmjs.com/package/pi-taskflow)
+[![CI](https://img.shields.io/github/actions/workflow/status/heggria/taskflow/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/heggria/taskflow/actions/workflows/ci.yml)
+[![Node](https://img.shields.io/badge/node-%E2%89%A522.19-35C99A?style=flat-square)](https://nodejs.org)
+[![License](https://img.shields.io/badge/license-MIT-35C99A?style=flat-square)](https://github.com/heggria/taskflow/blob/main/LICENSE)
+[![Hosts](https://img.shields.io/badge/hosts-6-7775FF?style=flat-square)](#install-on-your-host)
+[![Tests](https://img.shields.io/badge/tests-1%2C500%2B-7775FF?style=flat-square)](#built-to-survive-real-work)
+
+**English** · [简体中文](https://github.com/heggria/taskflow/blob/main/README.zh-CN.md)
+
+[Install](#install-on-your-host) · [Quickstart](#60-second-start) · [What's new in 0.2.9](#029-hermes-agent--verify-parity) · [0.2 compiler turn](#02-is-the-compiler-turn) · [Docs](https://heggria.github.io/taskflow/en/docs) · [Examples](https://github.com/heggria/taskflow/blob/main/examples)
+
+</div>
+
+---
+
+# Build multi-agent systems you can inspect before they run.
+
+**taskflow turns agent plans into compiled task graphs**: declared once, verified before model spend, executed in isolated subagents, resumed across sessions, replayed without tokens, and recomputed from the smallest stale frontier.
+
+It runs on the coding agent you already use:
+
+**Pi · Codex · Claude Code · OpenCode · Grok Build · Hermes Agent**
+
+```text
+JSON or .tf.ts
+      │
+      ▼
+ validate ──► Taskflow JSON ──► FlowIR + content hash
+                                      │
+                                      ▼
+                           isolated DAG runtime
+                                      │
+                         ┌────────────┼────────────┐
+                         ▼            ▼            ▼
+                      resume        replay      recompute
+```
+
+> Your host receives the final result. Intermediate transcripts stay inside the runtime unless you explicitly inspect them.
+
+## Why taskflow?
+
+Built-in subagent tools are excellent for one turn. The moment the work branches, retries, crosses sessions, or needs a quality gate, the plan becomes infrastructure.
+
+| | Ad-hoc agents / scripts | **taskflow** |
+|---|---|---|
+| **Plan** | Re-derived from prose or hidden in a script | **An explicit, versionable DAG** |
+| **Before execution** | Discover mistakes while spending | **Verify structure at zero model calls** |
+| **Intermediate output** | Floods the host context | **Stays isolated in the runtime** |
+| **Failure** | Start over or reconstruct state | **Resume from persisted phase state** |
+| **Changed input** | Re-run broadly | **Explain staleness and re-run the affected frontier** |
+| **Portability** | Coupled to one agent | **One JSON contract across six hosts** |
+
+The trade is deliberate: less arbitrary orchestration code, more **verifiability, observability, recovery, and reuse**.
+
+## 60-second start
+
+Install taskflow on [Pi](https://pi.dev):
+
+```bash
+pi install npm:pi-taskflow
+```
+
+Then ask naturally:
+
+> Use taskflow to audit `src/api` in parallel and return one prioritized report.
+
+The routing skill uses the same familiar `task` / `tasks` / `chain` shape:
+
+```json
+{
+  "chain": [
+    { "agent": "scout", "task": "Map the public API under src/api." },
+    {
+      "agent": "security-reviewer",
+      "task": "Audit this surface for missing auth and unsafe input boundaries:\n{previous.output}"
+    },
+    {
+      "agent": "reviewer",
+      "task": "Turn these findings into one prioritized report:\n{previous.output}"
+    }
+  ]
+}
+```
+
+That already gives you an isolated, tracked run. When the job needs real topology, declare the graph:
+
+```json
+{
+  "name": "audit-api",
+  "args": { "dir": { "default": "src/api" } },
+  "concurrency": 4,
+  "phases": [
+    {
+      "id": "discover",
+      "type": "agent",
+      "agent": "scout",
+      "task": "List source files under {args.dir}. Output ONLY a JSON array of {\"path\":\"...\"} objects.",
+      "output": "json"
+    },
+    {
+      "id": "audit-each",
+      "type": "map",
+      "over": "{steps.discover.json}",
+      "as": "file",
+      "agent": "security-reviewer",
+      "task": "Audit {file.path}. Cite evidence and assign severity.",
+      "dependsOn": ["discover"]
+    },
+    {
+      "id": "report",
+      "type": "reduce",
+      "from": ["audit-each"],
+      "agent": "reviewer",
+      "task": "Synthesize one prioritized report:\n{steps.audit-each.output}",
+      "dependsOn": ["audit-each"],
+      "final": true
+    }
+  ]
+}
+```
+
+Save it as `.pi/taskflows/audit-api.json`, then run:
+
+```text
+/tf:audit-api dir=src/api
+```
+
+On Codex, Claude Code, OpenCode, Grok Build, and Hermes Agent, run the same saved definition by name through `taskflow_run`. For long DAGs, use `mode: "background"`, then manage the durable run with `taskflow_runs` (`list` / `status` / `wait` / `cancel`); list output reports active concurrency and can filter `running` or `terminal` runs.
+
+[Follow the full quickstart →](https://heggria.github.io/taskflow/en/docs/getting-started)
+
+## See the graph run
+
+This is real output from a Pi run—not a mock dashboard:
+
+```text
+⊗ taskflow self-improve  6/7 · blocked · $0.095
+    ✓ discover            agent   deepseek-v4-flash  10t ↑38k ↓6.7k $0.011
+  ┌ ✓ write-runner-tests  agent   claude-sonnet-4-6  10t ↑13 ↓6.6k $0.020
+  ├ ✓ write-store-tests   agent   claude-sonnet-4-6  10t ↑11 ↓10k $0.018
+  ├ ✓ write-agents-tests  agent   claude-sonnet-4-6  10t ↑28 ↓13k $0.030
+  └ ✓ fix-stability       agent   claude-sonnet-4-6  10t ↑13 ↓3.9k $0.012
+    ✓ verify              gate    BLOCK 3 type errors in test files
+    ⊘ report              reduce  skipped · Gate blocked  ↳ fix-stability
+```
+
+The layout **is** the DAG. Parallel rails expose concurrency; long edges expose dependencies; the gate explains why downstream work stopped. No separate control plane is required to understand the run.
+
+## 0.2.9: Hermes Agent + verify parity
+
+Taskflow now ships on **Hermes Agent** as `hermes-taskflow`, bringing the same MCP control plane to a sixth host. Hermes children run with an ephemeral home, explicit toolsets, cwd-confined local reads, provider-only credential material, and an explicit opt-in for mutating `--yolo` phases.
+
+Pi's advertised `/tf verify <name>` command now matches the tool surface, including saved flow names containing spaces. Project discovery also stops at canonical home/temp boundaries, so ambient `/tmp/.pi` state cannot become a project by accident. [Full 0.2.9 notes →](https://github.com/heggria/taskflow/blob/main/CHANGELOG.md#029--2026-08-11)
+
+## 0.2.8: review, then confirm
+
+Pi approvals now separate **selection** from **commit**. Choose Reject, Edit guidance, or Approve with `R` / `E` / `A`, arrows, or Tab; press Enter to confirm. The safe default is Reject, and Escape or Ctrl-C still rejects immediately.
+
+Long proposals start collapsed. Press `V` to open an inline scrollable preview while the decision footer stays visible; short proposals remain open by default. Full notes: [CHANGELOG 0.2.8](https://github.com/heggria/taskflow/blob/main/CHANGELOG.md#028--2026-08-10).
+
+## 0.2.7: plan before spend · close the loop
+
+The 0.2 line made graphs **compiled and inspectable**. **0.2.7** makes the day-to-day loop feel finished: you can see the plan *before* any model call, and you can hear about the run *after* it finishes — without stuffing transcripts into the host.
+
+| Before spend | After spend |
+|---|---|
+| **`taskflow_plan` / `/tf plan`** — bind typed args, project phase order, mark dynamic refs, worst-case agent-call bound | **`hooks.onComplete` / `onFail` / `onBlocked`** — webhook, file, or argv-only command; summary payload only (`taskflow.hook.v1`) |
+| **`verify` / `lint`** still free | **`approval.timeoutMs` + `onExpire`** — HITL no longer waits forever |
+| **`recompute` savings line** — `reused N · rerun M · cutoff K · saved ~P%` | **`taskflow_analytics`** — last-N status, duration, fail/cache rates (read-only) |
+
+```bash
+# Zero tokens: see what would run and how expensive the worst case looks
+# MCP: taskflow_plan  ·  Pi: /tf plan my-flow '{"dir":"src"}'
+```
+
+```jsonc
+// Optional: fire-and-forget when a background run finishes
+{
+  "hooks": {
+    "onComplete": [{ "type": "file", "path": ".taskflow/hooks/last-complete.json" }]
+  }
+}
+```
+
+MCP hosts now expose **19 tools** (added `taskflow_plan` and `taskflow_analytics`). Starter templates: [`examples/templates/`](https://github.com/heggria/taskflow/blob/main/examples/templates/). Full notes: [CHANGELOG 0.2.7](https://github.com/heggria/taskflow/blob/main/CHANGELOG.md#027--2026-08-06).
+
+## 0.2 is the compiler turn
+
+Before 0.2, taskflow executed declarative graphs. Now the graph also has a compile-time frontend, a canonical intermediate representation, an append-only decision trace, offline replay, and incremental recompute.
+
+### Author in JSON or TypeScript
+
+JSON remains the portable runtime contract. For larger flows, `taskflow-dsl` adds a compile-time TypeScript authoring layer:
+
+```ts
+import { agent, flow, json, map, reduce } from "taskflow-dsl";
+
+export default flow("audit", (ctx) => {
+  ctx.budget({ maxUSD: 2 });
+
+  const files = agent("List files under {args.dir}", {
+    agent: "scout",
+    output: json<{ path: string }[]>(),
+  });
+
+  const audits = map(files, (file) =>
+    agent(`Audit ${file.path}`, { agent: "security-reviewer" }),
+  );
+
+  return reduce(
+    [audits],
+    (parts) => agent(`Write one report:\n${parts.audits.output}`),
+    { final: true },
+  );
+});
+```
+
+```bash
+pnpm add -D taskflow-dsl
+taskflow-dsl check audit.tf.ts
+taskflow-dsl build audit.tf.ts --emit both
+# → audit.taskflow.json + audit.flowir.json
+```
+
+`.tf.ts` is **compile-time only**. Hosts execute the emitted Taskflow JSON; they never interpret TypeScript.
+
+### Compile to a contract you can reason about
+
+FlowIR canonicalizes the graph and gives it a content hash. That compiled identity makes provenance and stale analysis inspectable, while the runtime adds content-addressed caching and deterministic tools:
+
+| Operation | What it answers | Model calls |
+|---|---|---:|
+| **`plan`** | What will run, which args bind, worst-case agent calls? | **0** |
+| `verify` / `compile` / `lint` | Is the graph structurally safe / lint-clean? | **0** |
+| `ir` | What is the canonical graph and content hash? | **0** |
+| `resume` | What unfinished work remains? (forks a new run; original untouched) | Only unfinished phases |
+| `trace` | What calls and runtime decisions actually happened? | **0** to inspect |
+| `replay` | What if thresholds or budgets had been different? | **0** |
+| `why-stale` | What changed, and what depends on it? | **0** |
+| `recompute` | What is the smallest observable affected frontier? (+ savings line) | Only affected phases |
+| `analytics` | How have recent runs of this flow behaved? | **0** |
+
+[Explore the compiler and runtime →](https://heggria.github.io/taskflow/en/docs/compiler-runtime/)
+
+## One runtime, 12 phase types
+
+| Family | Phases | Use them for |
+|---|---|---|
+| **Work** | `agent` · `parallel` · `map` · `reduce` · `script` | Single tasks, static fan-out, dynamic fan-out, aggregation, zero-token shell steps |
+| **Control** | `gate` · `approval` · `flow` · `loop` | Quality decisions, human checkpoints, composition, iterative refinement |
+| **Selection** | `tournament` · `race` | Best-of-N quality or first-success latency |
+| **Dynamic graph** | `expand` | Validate and execute a runtime-produced fragment, nested or grafted |
+
+Across those phase types, the DSL provides dependencies, conditions, retries, timeouts, output contracts, budgets, workspace isolation, and explicit final-output selection. Each kind accepts only the fields that are safe and meaningful for it; freshness-sensitive phases are excluded from cross-run caching.
+
+[Read the phase reference →](https://heggria.github.io/taskflow/en/docs/syntax/phase-types)
+
+## Runtime guarantees, not prompt conventions
+
+### Verify before spend
+
+Cycles, dangling dependencies, invalid references, impossible joins, unsafe dynamic fragments, and configuration hazards are rejected or surfaced before the expensive work starts.
+
+### Keep intermediate work out of the host context
+
+Agent-running phases execute in isolated subagent processes; control and script phases stay inside the runtime. Upstream outputs are wired into downstream inputs internally. Only `finalOutput` returns to the host unless you explicitly use `peek` or `trace`.
+
+### Survive sessions and failures
+
+Phase state is persisted atomically. Resume skips unchanged completed work; detached Pi runs can outlive the initiating session; an idle watchdog terminates stalled subagents.
+
+### Reuse work honestly
+
+Within-run resume is content-addressed. Cross-run caching is opt-in and can fingerprint Git commits, files, globs, environment variables, and TTLs. Change one declared input and only its dependents become stale.
+
+### Bound the blast radius
+
+Budgets, concurrency caps, retries, timeouts, nesting limits, dynamic-graph breadth caps, path containment, non-idempotent phase classification, and fail-closed approval behavior are runtime semantics—not suggestions in a prompt.
+
+### 0.2.1: safe dynamic cwd and Pi terminal reaping
+
+An invocation argument declared as `type: "relative-path"` may select a phase
+working directory with the exact form `cwd: "{args.package}"`. The bridge is
+default-off, requires host `resolve-only` authorization, and confines the
+canonical directory to the invocation root. Absolute paths, concatenation, and
+`{steps.*}` remain rejected; this compatibility bridge is not an OS sandbox.
+Resolve-only writer phases within one invocation are serialized before durable
+lease acquisition, so fan-out cannot self-timeout while separate processes
+remain protected by cross-process leases.
+
+Pi child agents no longer inherit ambient extensions by default. Trusted host
+settings can use an explicit extension allowlist or opt back into legacy
+inheritance. If a Pi child produces a validated final answer and terminal event
+but an extension keeps the process alive, Taskflow waits a bounded grace window,
+reaps the process group, and records `completionSource: "terminal-reap"` instead
+of reporting a false timeout.
+
+```json
+{
+  "taskflow": {
+    "piChild": {
+      "resourceProfile": "isolated",
+      "extensions": [],
+      "terminalGraceMs": 1500
+    }
+  }
+}
+```
+
+`allowlist` accepts explicit trusted extension files; `inherit` restores ambient
+Pi extension discovery as a compatibility mode. Flows cannot widen this host
+authority.
+
+[Read the core concepts →](https://heggria.github.io/taskflow/en/docs/concepts/)
+
+## Install on your host
+
+All packages require **Node.js ≥ 22.19.0**.
+
+### Pi
+
+```bash
+pi install npm:pi-taskflow
+```
+
+Pi provides the richest local experience: the `taskflow` tool, `/tf` commands, live DAG rendering, interactive approvals, background runs, and model-role setup.
+
+[Pi guide →](https://heggria.github.io/taskflow/en/docs/guides/pi)
+
+### OpenAI Codex
+
+```bash
+codex plugin marketplace add heggria/taskflow
+codex plugin add taskflow@taskflow
+```
+
+[Codex guide →](https://heggria.github.io/taskflow/en/docs/guides/codex)
+
+### Claude Code
+
+```bash
+claude plugin marketplace add heggria/taskflow
+claude plugin install claude-taskflow@taskflow
+```
+
+[Claude Code guide →](https://heggria.github.io/taskflow/en/docs/guides/claude-code)
+
+### OpenCode
+
+```bash
+opencode mcp add taskflow -- \
+  npx -y -p opencode-taskflow@0.2.9 opencode-taskflow-mcp
+```
+
+[OpenCode guide →](https://heggria.github.io/taskflow/en/docs/guides/opencode)
+
+### Grok Build
+
+```bash
+grok mcp add taskflow -- \
+  npx -y -p grok-taskflow@0.2.9 grok-taskflow-mcp
+```
+
+Grok Build support is new in 0.2. Its CLI stream does not report token/cost usage, so budget-declaring flows are rejected rather than silently running without enforcement.
+
+[Grok Build guide →](https://heggria.github.io/taskflow/en/docs/guides/grok-build)
+
+### Hermes Agent
+
+```bash
+hermes mcp add taskflow --command npx --args -y -p hermes-taskflow@0.2.9 hermes-taskflow-mcp
+# Prefer env in config.yaml (not CLI --env after args — can be stuffed into argv):
+#   mcp_servers.taskflow.env.PI_TASKFLOW_HERMES_UNSAFE_YOLO: "1"   # mutating only
+```
+
+Hermes quiet mode does not report token/cost usage, so budget-declaring flows are rejected rather than silently running without enforcement. Child agents use an ephemeral HERMES_HOME with only non-secret model/fallback routing, a routed-provider-only inference `auth.json`, and provider-allowlisted dotenv keys; parent MCP, skills, memory, sessions, and rules are not inherited. RO local-read → `taskflow_readonly_files`; else `taskflow_model_only` (never omit `-t`).
+
+[Hermes guide →](https://github.com/heggria/taskflow/blob/main/docs/hermes-mcp.md)
+
+
+## Built to survive real work
+
+<div align="center">
+
+**10 packages** · **6 hosts** · **12 phase types** · **18 built-in agents** · **1,500+ tests** · **MIT**
+
+</div>
+
+```text
+                              taskflow-core
+                 ┌──────────────┼───────────────┐
+                 │              │               │
+           taskflow-dsl   pi-taskflow   taskflow-mcp-core ─┐
+                                       taskflow-hosts ─────┼─ codex-taskflow
+                                                          ├─ claude-taskflow
+                                                          ├─ opencode-taskflow
+                                                          └─ grok-taskflow / hermes-taskflow
+```
+
+`taskflow-core` is host-neutral and imports no host SDK. `taskflow-mcp-core` implements stdio JSON-RPC without an MCP SDK dependency; `taskflow-hosts` owns the shared host process runners. The five MCP delivery packages bind both layers (and core), while Pi keeps its native adapter.
+
+The test suite covers orchestration semantics, persistence and file-lock races, cache freshness, path traversal, dynamic graph hardening, cancellation, budgets, all 12 phase kinds, FlowIR/replay/recompute, TypeScript DSL erasure, host argv contracts, MCP servers, and packed consumer imports.
+
+## Documentation
+
+| Start here | When you need |
+|---|---|
+| [Getting Started](https://heggria.github.io/taskflow/en/docs/getting-started) | Your first successful run |
+| [Concepts](https://heggria.github.io/taskflow/en/docs/concepts/) | DAGs, isolation, verification, resume, shared context |
+| [Syntax](https://heggria.github.io/taskflow/en/docs/syntax/) | Phase fields, control flow, budgets, caching, scorers |
+| [Compiler & Runtime](https://heggria.github.io/taskflow/en/docs/compiler-runtime/) | TypeScript DSL, FlowIR, replay, recompute, background runs |
+| [Host Guides](https://heggria.github.io/taskflow/en/docs/guides/) | Pi, Codex, Claude Code, OpenCode, Grok, and Hermes setup |
+| [Reference](https://heggria.github.io/taskflow/en/docs/reference/) | Commands, shorthand, and exact tool surfaces |
+| [Showcase](https://heggria.github.io/taskflow/en/docs/showcase/) | Real flows and case studies |
+| [0.2.0 Frontier Assessment](https://github.com/heggria/taskflow/blob/main/docs/taskflow-0.2.0-frontier-assessment.zh-CN.md) | Independent, evidence-based technical assessment (Chinese) |
+
+Also see [`examples/`](https://github.com/heggria/taskflow/blob/main/examples), the [changelog](https://github.com/heggria/taskflow/blob/main/CHANGELOG.md), and the [release guide](https://github.com/heggria/taskflow/blob/main/RELEASE.md).
+
+## Contributing
+
+```bash
+pnpm install
+pnpm run typecheck
+pnpm test
+pnpm run build
+pnpm run test:pack
+```
+
+Contributions are welcome. Start with [`CONTRIBUTING.md`](https://github.com/heggria/taskflow/blob/main/CONTRIBUTING.md) for the workflow and [`AGENTS.md`](https://github.com/heggria/taskflow/blob/main/AGENTS.md) for architecture and coding conventions.
+
+## License
+
+[MIT](https://github.com/heggria/taskflow/blob/main/LICENSE) © [heggria](https://github.com/heggria)
+
+<div align="center">
+
+**Declare once. Verify first. Recompute only what changed.**
+
+[Read the docs](https://heggria.github.io/taskflow/en/docs) · [Try an example](https://github.com/heggria/taskflow/blob/main/examples) · [View releases](https://github.com/heggria/taskflow/releases)
+
+</div>

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * hermes-taskflow public entry.
+ *
+ * The Hermes runner lives in `taskflow-hosts`. This package re-exports it so
+ * `import { hermesSubagentRunner, buildHermesArgs, ... } from "hermes-taskflow"`
+ * works. New code should import directly from `taskflow-hosts`; this re-export
+ * exists for a stable delivery surface.
+ *
+ * The delivery surface (MCP server + bin + Hermes config scaffold) is shipped
+ * from this package — see `./mcp/server.ts` and `./mcp/bin.ts`.
+ */
+export * from "taskflow-hosts/hermes";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * hermes-taskflow public entry.
+ *
+ * The Hermes runner lives in `taskflow-hosts`. This package re-exports it so
+ * `import { hermesSubagentRunner, buildHermesArgs, ... } from "hermes-taskflow"`
+ * works. New code should import directly from `taskflow-hosts`; this re-export
+ * exists for a stable delivery surface.
+ *
+ * The delivery surface (MCP server + bin + Hermes config scaffold) is shipped
+ * from this package — see `./mcp/server.ts` and `./mcp/bin.ts`.
+ */
+export * from "taskflow-hosts/hermes";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,cAAc,uBAAuB,CAAC"}

package/dist/mcp/bin.d.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * Executable entry for the taskflow MCP server, hermes-bound (the
+ * `hermes-taskflow-mcp` bin).
+ *
+ * Register with Hermes (~/.hermes/config.yaml):
+ *   mcp_servers:
+ *     taskflow:
+ *       command: "npx"
+ *       args: ["-y", "-p", "hermes-taskflow", "hermes-taskflow-mcp"]
+ *       env:
+ *         # PI_TASKFLOW_HERMES_UNSAFE_YOLO: "1"   # only if you need mutating agents
+ *         # PI_TASKFLOW_HERMES_READONLY_WEB: "1"  # RO phases may web_extract
+ *
+ * Prefer writing `env:` in config.yaml. Do not rely on `hermes mcp add … --env`
+ * stuffing flags into the node argv list.
+ *
+ * Or via CLI (no env):
+ *   hermes mcp add taskflow -- npx -y -p hermes-taskflow hermes-taskflow-mcp
+ *
+ * From a checkout of this repo (after `pnpm run build`):
+ *   command: "node"
+ *   args: ["/abs/path/to/packages/hermes-taskflow/dist/mcp/bin.js"]
+ *
+ * Hermes then launches this as a stdio MCP server and the taskflow_* tools
+ * become available (prefixed mcp_taskflow_*). Each subagent runs as an
+ * isolated `hermes chat -q -Q --ignore-rules` session. This file ships compiled to
+ * dist/mcp/bin.js, so no `--experimental-strip-types` flag is needed.
+ */
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/mcp/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/mcp/bin.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG"}

package/dist/mcp/bin.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * Executable entry for the taskflow MCP server, hermes-bound (the
+ * `hermes-taskflow-mcp` bin).
+ *
+ * Register with Hermes (~/.hermes/config.yaml):
+ *   mcp_servers:
+ *     taskflow:
+ *       command: "npx"
+ *       args: ["-y", "-p", "hermes-taskflow", "hermes-taskflow-mcp"]
+ *       env:
+ *         # PI_TASKFLOW_HERMES_UNSAFE_YOLO: "1"   # only if you need mutating agents
+ *         # PI_TASKFLOW_HERMES_READONLY_WEB: "1"  # RO phases may web_extract
+ *
+ * Prefer writing `env:` in config.yaml. Do not rely on `hermes mcp add … --env`
+ * stuffing flags into the node argv list.
+ *
+ * Or via CLI (no env):
+ *   hermes mcp add taskflow -- npx -y -p hermes-taskflow hermes-taskflow-mcp
+ *
+ * From a checkout of this repo (after `pnpm run build`):
+ *   command: "node"
+ *   args: ["/abs/path/to/packages/hermes-taskflow/dist/mcp/bin.js"]
+ *
+ * Hermes then launches this as a stdio MCP server and the taskflow_* tools
+ * become available (prefixed mcp_taskflow_*). Each subagent runs as an
+ * isolated `hermes chat -q -Q --ignore-rules` session. This file ships compiled to
+ * dist/mcp/bin.js, so no `--experimental-strip-types` flag is needed.
+ */
+import { startMcpServer } from "./server.js";
+startMcpServer(process.cwd())
+    .then(() => process.exit(0))
+    .catch((e) => {
+    // Never write non-JSON to stdout (it would corrupt the MCP stream); log to
+    // stderr and exit non-zero so the client sees the transport drop.
+    process.stderr.write(`taskflow mcp server fatal: ${e instanceof Error ? e.stack ?? e.message : String(e)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=bin.js.map

package/dist/mcp/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../../src/mcp/bin.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;KAC3B,IAAI,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;KAC3B,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE;IACZ,2EAA2E;IAC3E,kEAAkE;IAClE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,8BAA8B,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAC9G,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AACjB,CAAC,CAAC,CAAC"}

package/dist/mcp/server.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The Hermes Agent binding of the host-neutral MCP server (taskflow-mcp-core/server).
+ *
+ * The protocol layer, tool schemas, and handlers all live in core; this shim
+ * only closes the loop for Hermes: every subagent a flow spawns is itself a
+ * `hermes chat -q -Q` process (via hermesSubagentRunner). Kept as a module (not
+ * just bin.ts) so tests and embedders get the same pre-bound surface the bin runs.
+ */
+import type { RpcContext, RpcHandler } from "taskflow-mcp-core/jsonrpc";
+/** Per-call tool handlers with hermes subagent execution bound in. */
+export declare function makeToolHandlers(cwd: string): Record<string, (args: Record<string, unknown>, context?: RpcContext) => Promise<unknown>>;
+/** Full MCP method dispatch table (protocol + tools), hermes-bound. */
+export declare function makeMcpHandlers(cwd: string): Record<string, RpcHandler>;
+/** Start the stdio MCP server. Resolves when the client disconnects. */
+export declare function startMcpServer(cwd?: string): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAWxE,sEAAsE;AACtE,wBAAgB,gBAAgB,CAC/B,GAAG,EAAE,MAAM,GACT,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,EAAE,UAAU,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC,CAE3F;AAED,uEAAuE;AACvE,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAEvE;AAED,wEAAwE;AACxE,wBAAgB,cAAc,CAAC,GAAG,GAAE,MAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzE"}

package/dist/mcp/server.js

@@ -0,0 +1,30 @@
+/**
+ * The Hermes Agent binding of the host-neutral MCP server (taskflow-mcp-core/server).
+ *
+ * The protocol layer, tool schemas, and handlers all live in core; this shim
+ * only closes the loop for Hermes: every subagent a flow spawns is itself a
+ * `hermes chat -q -Q` process (via hermesSubagentRunner). Kept as a module (not
+ * just bin.ts) so tests and embedders get the same pre-bound surface the bin runs.
+ */
+import { makeMcpHandlers as coreMakeMcpHandlers, makeToolHandlers as coreMakeToolHandlers, startMcpServer as coreStartMcpServer, } from "taskflow-mcp-core/server";
+import { hermesSubagentRunner } from "taskflow-hosts";
+const HOST_OPTIONS = {
+    host: "hermes",
+    detachedRunner: {
+        module: import.meta.resolve("taskflow-hosts/hermes"),
+        exportName: "hermesSubagentRunner",
+    },
+};
+/** Per-call tool handlers with hermes subagent execution bound in. */
+export function makeToolHandlers(cwd) {
+    return coreMakeToolHandlers(cwd, hermesSubagentRunner, HOST_OPTIONS);
+}
+/** Full MCP method dispatch table (protocol + tools), hermes-bound. */
+export function makeMcpHandlers(cwd) {
+    return coreMakeMcpHandlers(cwd, hermesSubagentRunner, HOST_OPTIONS);
+}
+/** Start the stdio MCP server. Resolves when the client disconnects. */
+export function startMcpServer(cwd = process.cwd()) {
+    return coreStartMcpServer(hermesSubagentRunner, cwd, HOST_OPTIONS);
+}
+//# sourceMappingURL=server.js.map

package/dist/mcp/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACN,eAAe,IAAI,mBAAmB,EACtC,gBAAgB,IAAI,oBAAoB,EACxC,cAAc,IAAI,kBAAkB,GACpC,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD,MAAM,YAAY,GAAG;IACpB,IAAI,EAAE,QAAQ;IACd,cAAc,EAAE;QACf,MAAM,EAAE,OAAO,IAAI,CAAC,OAAO,CAAC,uBAAuB,CAAC;QACpD,UAAU,EAAE,sBAAsB;KAClC;CACQ,CAAC;AAEX,sEAAsE;AACtE,MAAM,UAAU,gBAAgB,CAC/B,GAAW;IAEX,OAAO,oBAAoB,CAAC,GAAG,EAAE,oBAAoB,EAAE,YAAY,CAAC,CAAC;AACtE,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,eAAe,CAAC,GAAW;IAC1C,OAAO,mBAAmB,CAAC,GAAG,EAAE,oBAAoB,EAAE,YAAY,CAAC,CAAC;AACrE,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,cAAc,CAAC,GAAG,GAAW,OAAO,CAAC,GAAG,EAAE;IACzD,OAAO,kBAAkB,CAAC,oBAAoB,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC;AACpE,CAAC"}