@loomfsm/mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend, and
+      hold each Contributor harmless for any liability incurred by, or
+      claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 teaarte
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied. See the License for the specific language governing permissions
+   and limitations under the License.

package/cc-adapter/commands/done.md

@@ -0,0 +1,30 @@
+---
+mcp_protocol_required: "^3.0"
+---
+
+# /done — review a finished task
+
+<!--
+  Read-only by design. The task is already finalized by the server when it
+  reaches its terminal step; this command never mutates state and never
+  acts on the user's behalf. If the task is stuck, the only repair path is
+  the server-issued recovery options — never a hand-edit of the state DB.
+
+  Bundle-neutral: it renders whatever the kernel's summary carries
+  (verdict, counts, outputs) and never assumes a particular kind of work.
+  Any "next step" it offers (a commit, a publish, a hand-off) is a
+  suggestion the user acts on, not something this command performs.
+
+  `loom` below is the alias this MCP server is registered under in the
+  host's MCP config; swap the `mcp__loom__` prefix if you registered it
+  under a different name.
+-->
+
+Call `mcp__loom__pipeline_state_get({ project_dir: <cwd>, format: "summary" })` to check readiness.
+
+- If the task is in an **error / stuck** state (or still has pending agents or an unanswered gate) → display the recovery options verbatim and call `mcp__loom__pipeline_recover({ project_dir, driver_state_id, choice })` with the option the user picks. Stop here; rerun `/done` once the task settles.
+- Otherwise (in progress with nothing pending, or already completed):
+  1. Call `mcp__loom__pipeline_state_get({ project_dir, format: "json" })` for the final metrics.
+  2. Display the kernel summary to the user verbatim — verdict, agent count, outputs, key findings.
+  3. Optionally suggest a sensible next step for that result (for a code task that is usually a commit message). It is a suggestion only — the user acts on it.
+  4. Do **not** perform the next step yourself, do **not** auto-commit, and do **not** mutate state.

package/cc-adapter/commands/task.md

@@ -0,0 +1,29 @@
+---
+mcp_protocol_required: "^3.0"
+---
+
+# /task — start or drive a pipeline task
+
+<!--
+  This file is a dumb router. It does no flag parsing, no output
+  interpretation, and knows zero gate vocabulary: every semantic decision
+  (which preset a flag maps to, what a gate's answers are, how to recover)
+  lives server-side. That is why adding a new preset, gate role, or bundle
+  never edits this file — the server ships the schema, the router renders it.
+
+  `loom` below is the alias this MCP server is registered under in the
+  host's MCP config; if you registered it under a different name, swap the
+  `mcp__loom__` prefix to match. No other host detail is assumed.
+-->
+
+Call `mcp__loom__pipeline_run_task({ project_dir: <cwd>, task: "$ARGUMENTS", client_idempotency_uuid: <one crypto.randomUUID() bound to this invocation; reuse it verbatim on any transport-retry>, client_capabilities: { honors_shuttle: true } })`. Pass `$ARGUMENTS` exactly as typed — the server parses any leading flag.
+
+Then loop on the returned response's `status`:
+
+- **`spawn-agent`** → run the spawn with the Task tool using `spawn_request.{description, prompt, model}` (plus `subagent_type` from `spawn_request.extras` when present). Deliver the result back: `mcp__loom__pipeline_continue_task({ project_dir, driver_state_id, input: { type: "agent-result", agent_run_id, agent_output } })`.
+- **`spawn-agents-parallel`** → run every entry in `spawns` the same way, then deliver all results together: `mcp__loom__pipeline_continue_task({ project_dir, driver_state_id, input: { type: "agents-results", results: [{ agent_run_id, agent_output }, …] } })`.
+- **`ask-user`** → show `message` and `valid_answers` to the user **verbatim** (the schema names exactly which replies are accepted and what each produces — do not invent or filter options). Deliver their choice: `mcp__loom__pipeline_continue_task({ project_dir, driver_state_id, input: { type: "user-answer", gate_event_id, … } })` with the fields the chosen option declares.
+- **`complete`** → display `summary`, suggest `/done`, and stop.
+- **`error`** → display `message` and `recovery_options` verbatim, then call `mcp__loom__pipeline_recover({ project_dir, driver_state_id, choice })` with the option the user picks (passing `agent_run_ids` when that option lists them).
+
+After any `pipeline_continue_task` or `pipeline_recover`, loop again on the new response's `status`. Never edit the state DB by hand — `pipeline_recover` is the only repair path.

package/cc-adapter/pipeline-guard.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# pipeline-guard.sh — Claude Code PreToolUse hook (ADVISORY ONLY).
+#
+# Blocks the obvious accidental shell mutations of the pipeline state DB
+# (`.claude/state.db`): a direct `rm`, `mv`, output-redirect (`>`), or
+# in-place `sed -i`. It is belt-and-suspenders for fat-fingered keystrokes
+# — NOT a security boundary. It is trivially bypassed by any non-shell
+# write path (a Python/Node one-liner, a symlink, a wrapper script). The
+# real integrity boundary is the kernel's atomic transactions plus its
+# on-commit invariants: a write that does not go through them leaves the
+# DB failing invariant checks on the next kernel touch, which recovery
+# rolls back. Treat this script accordingly.
+#
+# Contract: reads Claude Code's PreToolUse JSON on stdin, inspects only the
+# Bash tool's command string, and denies the four mutations above when the
+# target path ends in `.claude/state.db`. Everything else passes through.
+# Parsing is defensive — a missing/unknown field falls back to allow.
+
+set -u
+
+payload="$(cat 2>/dev/null || true)"
+
+# Extract the shell command. Prefer jq; fall back to a minimal extractor so
+# the hook still functions if jq is absent. Either failure → empty → allow.
+command_str=""
+if command -v jq >/dev/null 2>&1; then
+  command_str="$(printf '%s' "$payload" | jq -r '.tool_input.command // empty' 2>/dev/null || true)"
+else
+  command_str="$(printf '%s' "$payload" \
+    | sed -n 's/.*"command"[[:space:]]*:[[:space:]]*"\(.*\)".*/\1/p' \
+    | head -n1)"
+fi
+
+# Only the state DB is in scope. No mention → allow.
+case "$command_str" in
+  *".claude/state.db"*) : ;;
+  *) exit 0 ;;
+esac
+
+# Match the four accidental-mutation shapes against the state DB path.
+is_mutation=0
+case "$command_str" in
+  *"rm "*".claude/state.db"*)     is_mutation=1 ;;
+  *"mv "*".claude/state.db"*)     is_mutation=1 ;;
+  *">"*".claude/state.db"*)       is_mutation=1 ;;
+  *"sed -i"*".claude/state.db"*)  is_mutation=1 ;;
+esac
+
+if [ "$is_mutation" -eq 1 ]; then
+  reason="refused: direct shell mutation of .claude/state.db — use pipeline_recover. (advisory guard; the real boundary is the kernel's transactional invariants)"
+  # Emit Claude Code's structured deny decision on stdout AND exit non-zero,
+  # so either contract interpretation treats this as a block.
+  printf '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"%s"}}\n' "$reason"
+  printf '%s\n' "$reason" >&2
+  exit 2
+fi
+
+exit 0

package/cc-adapter/pipeline-stop.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# pipeline-stop.sh — Claude Code Stop hook (ADVISORY, NON-BLOCKING).
+#
+# Prints a short human-readable hint about the pipeline's state when a
+# session stops — never blocks the stop, never writes the DB. It is a
+# courtesy note, not enforcement: the kernel owns task lifecycle and
+# integrity through its transactions and invariants.
+#
+# `sqlite3` is a SOFT dependency: if the CLI is missing, the DB does not
+# exist, or any read fails, the hook degrades to a generic note and exits
+# 0. Parsing of Claude Code's Stop payload is defensive — a missing field
+# never aborts the hook.
+
+set -u
+
+payload="$(cat 2>/dev/null || true)"
+
+# Working dir from the payload if present, else the current directory.
+cwd=""
+session_id=""
+if command -v jq >/dev/null 2>&1; then
+  cwd="$(printf '%s' "$payload" | jq -r '.cwd // empty' 2>/dev/null || true)"
+  session_id="$(printf '%s' "$payload" | jq -r '.session_id // empty' 2>/dev/null || true)"
+fi
+[ -n "$cwd" ] || cwd="$(pwd)"
+
+db="$cwd/.claude/state.db"
+
+note() { printf 'pipeline: %s\n' "$1"; exit 0; }
+
+# Soft-dependency + existence guards → generic note, never a failure.
+command -v sqlite3 >/dev/null 2>&1 || note "state hint unavailable (sqlite3 CLI not on PATH)."
+[ -f "$db" ]                       || note "no task state for this project."
+
+# Best-effort single read. Any failure degrades to the generic note.
+row="$(sqlite3 "$db" \
+  "SELECT COALESCE(p.owner_id,''), p.status,
+          COALESCE((SELECT COUNT(*) FROM pending_agents), 0),
+          COALESCE((SELECT pending_user_answer FROM driver_state WHERE id = 1), '')
+   FROM pipeline_state p WHERE p.id = 1;" 2>/dev/null || true)"
+[ -n "$row" ] || note "no task state for this project."
+
+owner="$(printf '%s' "$row"  | cut -d'|' -f1)"
+status="$(printf '%s' "$row" | cut -d'|' -f2)"
+pending_agents="$(printf '%s' "$row" | cut -d'|' -f3)"
+pending_answer="$(printf '%s' "$row" | cut -d'|' -f4)"
+
+owner_hint=""
+if [ -n "$owner" ] && [ -n "$session_id" ] && [ "$owner" != "$session_id" ]; then
+  owner_hint=" (owned by another session)"
+fi
+
+# Tri-state hint, derived top-down. Terminal states short-circuit first.
+case "$status" in
+  completed|abandoned)
+    note "task is finalized (status=$status)$owner_hint." ;;
+esac
+
+if [ -n "$pending_answer" ]; then
+  note "gate-paused — a checkpoint is awaiting your answer$owner_hint."
+elif [ "${pending_agents:-0}" -gt 0 ]; then
+  note "in-flight — $pending_agents agent(s) still executing$owner_hint."
+else
+  note "accept-pending — task in progress, nothing dispatched$owner_hint."
+fi

package/dist/src/bin/stdio.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/bin/stdio.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+// Stdio entrypoint a host's MCP config spawns. Connects the server over
+// stdin/stdout and exits non-zero if the transport fails to connect.
+//
+// This is where the production dependencies wire in: `assembleRegistry`
+// loads the installed bundle + the zero-config shuttle provider for a
+// project (so the active-task tools have a real flow to tick), and the
+// operator-authored project-dir allowlist gates which projects are
+// reachable. The allowlist is default-deny — a project is permitted only
+// after its absolute path is added to the file (see SETUP.md). This
+// entrypoint ensures the file and its parent directory exist so the
+// operator has a place to add entries, but it NEVER auto-enrolls a
+// project: a self-enrolling transport would defeat the gate.
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { assembleRegistry } from "../bootstrap.js";
+import { runStdioServer } from "../server.js";
+// Mirror the kernel's default allowlist location so the path the gate
+// reads and the path this entrypoint seeds are the same file.
+function resolveAllowlistPath() {
+    const home = process.env.HOME ?? homedir();
+    return join(home, ".claude", "projects.allow");
+}
+function ensureAllowlistExists(path) {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        // `wx` creates the file only when it is absent — an operator-authored
+        // allowlist is never overwritten.
+        writeFileSync(path, "", { flag: "wx" });
+    }
+    catch {
+        // Already present (the common case) or unwritable; either way the
+        // gate treats a missing/empty file as default-deny.
+    }
+}
+const allowlistPath = resolveAllowlistPath();
+ensureAllowlistExists(allowlistPath);
+runStdioServer({ resolveRegistry: assembleRegistry, allowlistPath }).catch((err) => {
+    process.stderr.write(`mcp-server failed to start: ${String(err)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=stdio.js.map

package/dist/src/bin/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../../../src/bin/stdio.ts"],"names":[],"mappings":";AACA,wEAAwE;AACxE,qEAAqE;AACrE,EAAE;AACF,wEAAwE;AACxE,sEAAsE;AACtE,uEAAuE;AACvE,mEAAmE;AACnE,yEAAyE;AACzE,oEAAoE;AACpE,oEAAoE;AACpE,mEAAmE;AACnE,6DAA6D;AAE7D,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C,sEAAsE;AACtE,8DAA8D;AAC9D,SAAS,oBAAoB;IAC3B,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,OAAO,EAAE,CAAC;IAC3C,OAAO,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC;AACjD,CAAC;AAED,SAAS,qBAAqB,CAAC,IAAY;IACzC,IAAI,CAAC;QACH,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9C,sEAAsE;QACtE,kCAAkC;QAClC,aAAa,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,kEAAkE;QAClE,oDAAoD;IACtD,CAAC;AACH,CAAC;AAED,MAAM,aAAa,GAAG,oBAAoB,EAAE,CAAC;AAC7C,qBAAqB,CAAC,aAAa,CAAC,CAAC;AAErC,cAAc,CAAC,EAAE,eAAe,EAAE,gBAAgB,EAAE,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;IAC1F,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,+BAA+B,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACrE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/src/bootstrap.d.ts

@@ -0,0 +1,4 @@
+import { type LLMProvider, type Registry } from "@loomfsm/kernel";
+export declare function createAssembleRegistry(providers: LLMProvider[]): (projectDir: string) => Promise<Registry>;
+export declare function assembleRegistry(projectDir: string): Promise<Registry>;
+export declare function _resetRegistryCacheForTest(): void;

package/dist/src/bootstrap.js

@@ -0,0 +1,130 @@
+// Production registry assembly — the wiring the active-task tools need
+// to tick a real flow.
+//
+// `assembleRegistry(projectDir)` is the resolver the stdio entrypoint
+// injects as `ServerDeps.resolveRegistry`. It does the three things a
+// project needs before its first FSM tick:
+//
+//   1. Resolve the bundle's source root (where `agents/` and the prompt
+//      templates live) so the loader can read every agent's `.md` body
+//      off disk into the prompt map.
+//   2. Open the project DB (kernel migrations apply on first open) and
+//      idempotently reconcile the bundle's manifest into the project's
+//      installed-extensions table — the loader refuses a bundle whose
+//      manifest row is absent, and a re-run with an unchanged manifest
+//      is a no-op (no duplicate rows, no spurious change event).
+//   3. Load the bundle with the zero-config shuttle provider and return
+//      the assembled Registry.
+//
+// The Registry is cached per project for the process lifetime: the FSM
+// reads a fresh state snapshot every tick, but the registry itself is a
+// static product of (bundle source + installed manifest) that does not
+// change between ticks, so building it once is safe. A rejected build is
+// evicted so a transient failure (e.g. a not-yet-built bundle dist) does
+// not poison every later call.
+//
+// This lives in the transport package for now; a shared runtime home is
+// the natural next move once a second entrypoint wants the same wiring.
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, resolve } from "node:path";
+import codeBundle, { codeManifest } from "@loomfsm/bundle-code";
+import { captureNow, loadBundle, openDb, reconcileExtensions, } from "@loomfsm/kernel";
+import { claudeCodeShuttleProvider } from "@loomfsm/provider-claude-code-shuttle";
+// Resolve the bundle package root through Node's own resolver so it works
+// both from an installed `node_modules/@loomfsm/bundle-code` and from a
+// workspace symlink in the monorepo. `package.json` is always resolvable
+// regardless of any `exports` map; its directory is the source root the
+// loader resolves each agent's `template_path` against.
+const bundleSourceDir = dirname(createRequire(import.meta.url).resolve("@loomfsm/bundle-code/package.json"));
+// Synthetic source tag for the reconciled manifest. The reconcile core
+// treats this as an opaque label (it only surfaces in a fallback id when
+// validation fails, which cannot happen for the curated bundle manifest).
+const BUNDLE_MANIFEST_SOURCE = "@loomfsm/bundle-code:manifest";
+// Build a per-project registry resolver over a fixed provider set. The
+// provider SET is a deployment choice the entrypoint owns — the generic
+// server bundles only the zero-config shuttle default; a deployment that
+// wants other backends (a local model, a hosted API) injects them here
+// rather than the server hardcoding every provider package. Per-agent /
+// per-phase routing among the registered set is then a project-level
+// `.claude/providers.json` (read at build).
+//
+// Concurrent first calls share one in-flight build via the cached promise;
+// a rejected build is evicted so a transient failure does not poison later
+// calls.
+export function createAssembleRegistry(providers) {
+    return makeResolver(providers, new Map());
+}
+function makeResolver(providers, cache) {
+    return function assemble(projectDir) {
+        const key = resolve(projectDir);
+        const cached = cache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const building = buildRegistry(projectDir, providers).catch((err) => {
+            cache.delete(key);
+            throw err;
+        });
+        cache.set(key, building);
+        return building;
+    };
+}
+// The default resolver's cache is module-level so the test seam can clear
+// it; resolvers from `createAssembleRegistry` own private caches.
+const defaultResolverCache = new Map();
+const defaultResolver = makeResolver([claudeCodeShuttleProvider], defaultResolverCache);
+// The production resolver the stdio entrypoint injects: zero-config shuttle
+// only. Per-agent provider routing still works for any provider in this
+// set; to route to other backends, an entrypoint builds its own resolver
+// via `createAssembleRegistry([...])`.
+export function assembleRegistry(projectDir) {
+    return defaultResolver(projectDir);
+}
+async function buildRegistry(projectDir, providers) {
+    const now = captureNow();
+    // Open the project DB so kernel migrations apply before the loader
+    // reads the installed-extensions table.
+    openDb(projectDir);
+    // Idempotent: an unchanged manifest row is left as-is.
+    await reconcileExtensions({
+        manifests: [{ path: BUNDLE_MANIFEST_SOURCE, raw: codeManifest }],
+        project_dir: projectDir,
+        now,
+    });
+    return await loadBundle({
+        bundle: codeBundle,
+        bundle_source_dir: bundleSourceDir,
+        project_dir: projectDir,
+        providers,
+        providers_config: readProvidersConfig(projectDir),
+        now,
+    });
+}
+// Optional per-project provider routing, read from `.claude/providers.json`
+// (the same `.claude/` dir the state DB lives in). Absent → no routing
+// (every agent resolves to the default provider). Present-but-malformed is
+// surfaced as an error rather than silently ignored; the kernel router
+// validates the parsed shape and refuses unknown providers/tiers.
+function readProvidersConfig(projectDir) {
+    const path = join(projectDir, ".claude", "providers.json");
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined; // absent → no routing config
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`invalid provider routing config at ${path}: ${err.message}`);
+    }
+}
+// Test seam: drop the default resolver's per-project cache so a suite can
+// rebuild a registry for a reused project path. Resolvers built via
+// `createAssembleRegistry` own their own caches (fresh per construction).
+export function _resetRegistryCacheForTest() {
+    defaultResolverCache.clear();
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/src/bootstrap.js.map

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

package/dist/src/index.d.ts

@@ -0,0 +1,21 @@
+export { createServer, runStdioServer } from "./server.js";
+export type { CreateServerHandle, ServerDeps, ToolRegistry } from "./server.js";
+export { createMetaTool } from "./tools/meta.js";
+export type { MetaInputWithProject } from "./tools/meta.js";
+export { createStateGetTool } from "./tools/state-get.js";
+export { createExtensionsListTool } from "./tools/extensions-list.js";
+export { createRunTaskTool } from "./tools/run-task.js";
+export type { RunTaskDeps } from "./tools/run-task.js";
+export { createContinueTaskTool } from "./tools/continue-task.js";
+export type { ContinueTaskDeps } from "./tools/continue-task.js";
+export { createRecoverTool } from "./tools/recover.js";
+export type { RecoverDeps } from "./tools/recover.js";
+export { createIssueCrossOwnerMarkerTool } from "./tools/issue-marker.js";
+export type { IssueMarkerDeps } from "./tools/issue-marker.js";
+export { createBackupTool } from "./tools/backup.js";
+export type { BackupDeps } from "./tools/backup.js";
+export { createRestoreTool } from "./tools/restore.js";
+export type { RestoreDeps } from "./tools/restore.js";
+export { createTransportAdapter, shape } from "./transport-adapter.js";
+export { FLAG_TO_PRESET, parseTaskArgs } from "./lib/parse-task-args.js";
+export type { BackupInput, BackupResponse, BypassMarkerInput, ClientCapabilities, ContinueTaskRequestInput, ContinueTaskResponse, ExtensionsListEntry, ExtensionsListInput, ExtensionsListResponse, ExtensionStatus, IssueCrossOwnerMarkerInput, IssueCrossOwnerMarkerResponse, MetaBundle, MetaInput, MetaProviders, MetaSandbox, MetaTransports, ParsedTaskArgs, PipelineMetaResponse, PipelineStateView, RecoverTaskInput, RecoverTaskResponse, RecoveryChoiceInput, RestoreInput, RestoreResponse, RunTaskInput, RunTaskResponse, SpawnRequest, StateGetFormat, StateGetInput, ToolHandler, TransportResponse, } from "./types.js";

package/dist/src/index.js

@@ -0,0 +1,16 @@
+// Public barrel — anything callers import as `@loomfsm/mcp-server` lives
+// here. Internal tool modules and the version constants stay private
+// to the package layout.
+export { createServer, runStdioServer } from "./server.js";
+export { createMetaTool } from "./tools/meta.js";
+export { createStateGetTool } from "./tools/state-get.js";
+export { createExtensionsListTool } from "./tools/extensions-list.js";
+export { createRunTaskTool } from "./tools/run-task.js";
+export { createContinueTaskTool } from "./tools/continue-task.js";
+export { createRecoverTool } from "./tools/recover.js";
+export { createIssueCrossOwnerMarkerTool } from "./tools/issue-marker.js";
+export { createBackupTool } from "./tools/backup.js";
+export { createRestoreTool } from "./tools/restore.js";
+export { createTransportAdapter, shape } from "./transport-adapter.js";
+export { FLAG_TO_PRESET, parseTaskArgs } from "./lib/parse-task-args.js";
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,qEAAqE;AACrE,yBAAyB;AAEzB,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAG3D,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAE1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGvD,OAAO,EAAE,sBAAsB,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAEvE,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/src/lib/parse-task-args.d.ts

@@ -0,0 +1,4 @@
+import type { ParsedTaskArgs } from "../types.js";
+export type { ParsedTaskArgs };
+export declare const FLAG_TO_PRESET: Record<string, string>;
+export declare function parseTaskArgs(raw: string): ParsedTaskArgs;