handoff-mcp-server 0.26.0 → 0.27.0

package/scripts/cargo-env.sh

@@ -1,29 +0,0 @@
-# shellcheck shell=sh
-# cargo-env.sh — make cargo commands work across heterogeneous dev environments.
-#
-# Some environments (e.g. a Docker image where CARGO_HOME=/usr/local/cargo is
-# owned by root) expose a CARGO_HOME that the current user cannot write to.
-# cargo then fails to download/cache crates or fetch the advisory-db, breaking
-# the git hooks even though nothing is wrong with the code.
-#
-# This script detects an unwritable CARGO_HOME and transparently falls back to
-# the per-user $HOME/.cargo, which every supported environment can write to.
-# When CARGO_HOME is already writable (local macOS, a synced Mac, or simply
-# unset so cargo uses its default ~/.cargo) it leaves the environment untouched.
-#
-# Usage (from a hook or shell):
-#   . scripts/cargo-env.sh && cargo <args>
-
-# Resolve the directory cargo would use right now.
-_cargo_home="${CARGO_HOME:-$HOME/.cargo}"
-
-# Probe writability with a temp file; fall back to $HOME/.cargo if we can't write.
-if ! ( mkdir -p "$_cargo_home" 2>/dev/null && touch "$_cargo_home/.cargo-env-wtest" 2>/dev/null ); then
-  export CARGO_HOME="$HOME/.cargo"
-  mkdir -p "$CARGO_HOME" 2>/dev/null || true
-else
-  rm -f "$_cargo_home/.cargo-env-wtest" 2>/dev/null || true
-  export CARGO_HOME="$_cargo_home"
-fi
-
-unset _cargo_home

package/scripts/handoff-memory-hook.py

@@ -1,208 +0,0 @@
-#!/usr/bin/env python3
-"""Claude Code hook wrapper for handoff-mcp project memory.
-
-This is the **fallback path** for memory auto-injection. The preferred wiring is
-a native ``mcp_tool`` hook that calls ``handoff_memory_query`` / ``handoff_memory_cleanup``
-directly (see README "Project Memory"); this script exists for Claude Code
-versions that lack the ``mcp_tool`` hook type, by translating a Claude Code hook
-event into a single JSON-RPC ``tools/call`` against the handoff-mcp server and
-emitting the result as ``hookSpecificOutput.additionalContext``.
-
-It speaks the server's line-delimited JSON-RPC over stdio: one request object on
-one line in, one response object on one line out. ``handoff_memory_query`` /
-``handoff_memory_cleanup`` return their payload as a JSON *string* inside
-``result.content[0].text`` (so both this wrapper and the native hook path parse
-it identically), which this script re-parses.
-
-Wiring (in ``~/.claude/settings.json`` — do NOT commit this into a repo):
-
-    {
-      "hooks": {
-        "UserPromptSubmit": [
-          { "hooks": [ { "type": "command",
-              "command": "handoff-mcp-memory-hook" } ] }
-        ],
-        "PreToolUse": [
-          { "matcher": "Edit|Write|MultiEdit",
-            "hooks": [ { "type": "command",
-              "command": "handoff-mcp-memory-hook" } ] }
-        ],
-        "SessionStart": [
-          { "hooks": [ { "type": "command",
-              "command": "handoff-mcp-memory-hook" } ] }
-        ]
-      }
-    }
-
-The same script handles all three events; it picks the tool from
-``hook_event_name`` on stdin.
-
-Environment:
-- ``HANDOFF_MCP_BIN`` — path to the ``handoff-mcp`` binary (default: ``handoff-mcp``
-  resolved on ``PATH``).
-
-Design contract: this script must **never break the session**. On any error
-(binary missing, bad JSON, timeout) it prints nothing and exits 0 — a memory
-miss is silent, never a blocked prompt.
-"""
-
-# `X | None` annotations are evaluated lazily so this runs on Python 3.7+
-# (a hook host may not have 3.10). The annotations are never evaluated at runtime.
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import subprocess
-import sys
-
-# Map a Claude Code hook event to the memory tool it drives.
-QUERY_EVENTS = {"UserPromptSubmit", "PreToolUse"}
-CLEANUP_EVENTS = {"SessionStart"}
-
-# How long to wait for the server to answer one request, in seconds. The query
-# is in-memory and sub-millisecond; this is just a safety net so a hung binary
-# can never stall the prompt.
-TIMEOUT_SECONDS = 5.0
-
-
-def _server_bin() -> str | None:
-    """Resolve the handoff-mcp binary path, or None if it can't be found."""
-    explicit = os.environ.get("HANDOFF_MCP_BIN")
-    if explicit:
-        return explicit if os.path.exists(explicit) else None
-    return shutil.which("handoff-mcp")
-
-
-def _call(bin_path: str, tool: str, arguments: dict) -> dict | None:
-    """Send one ``tools/call`` line and parse the inner JSON payload.
-
-    Returns the decoded inner object (e.g. ``{"memories": [...]}`), or None on
-    any transport / decode failure. The server is stateless per line, so no
-    ``initialize`` handshake is needed — a bare ``tools/call`` is answered.
-    """
-    request = {
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": "tools/call",
-        "params": {"name": tool, "arguments": arguments},
-    }
-    try:
-        proc = subprocess.run(
-            [bin_path],
-            input=json.dumps(request) + "\n",
-            capture_output=True,
-            text=True,
-            timeout=TIMEOUT_SECONDS,
-        )
-    except (OSError, subprocess.TimeoutExpired):
-        return None
-
-    # The response is the first non-empty stdout line (stderr carries the
-    # startup banner and is ignored).
-    line = next((ln for ln in proc.stdout.splitlines() if ln.strip()), None)
-    if not line:
-        return None
-    try:
-        envelope = json.loads(line)
-        text = envelope["result"]["content"][0]["text"]
-        return json.loads(text)
-    except (json.JSONDecodeError, KeyError, IndexError, TypeError):
-        return None
-
-
-def _file_paths_from_tool_input(tool_input) -> list[str]:
-    """Pull file paths out of a PreToolUse ``tool_input`` (Edit/Write/MultiEdit)."""
-    if not isinstance(tool_input, dict):
-        return []
-    paths = []
-    fp = tool_input.get("file_path")
-    if isinstance(fp, str) and fp:
-        paths.append(fp)
-    # MultiEdit and similar may carry an edits array; each can name a file.
-    for edit in tool_input.get("edits", []) or []:
-        if isinstance(edit, dict):
-            efp = edit.get("file_path")
-            if isinstance(efp, str) and efp:
-                paths.append(efp)
-    return paths
-
-
-def _emit(event: str, context: str) -> None:
-    """Print a Claude Code hook output object carrying additionalContext."""
-    if not context:
-        return
-    out = {
-        "hookSpecificOutput": {
-            "hookEventName": event,
-            "additionalContext": context,
-        }
-    }
-    print(json.dumps(out))
-
-
-def _format_memories(payload: dict) -> str:
-    """Turn a ``handoff_memory_query`` payload into an injectable context block."""
-    memories = payload.get("memories") or []
-    if not memories:
-        return ""
-    lines = ["Relevant project memories (handoff-mcp):"]
-    for m in memories:
-        text = (m.get("text") or "").strip()
-        if not text:
-            continue
-        kind = m.get("kind") or "memory"
-        lines.append(f"- [{kind}] {text}")
-    # Only a header with no bullets means nothing useful to inject.
-    return "\n".join(lines) if len(lines) > 1 else ""
-
-
-def main() -> int:
-    raw = sys.stdin.read()
-    try:
-        hook = json.loads(raw) if raw.strip() else {}
-    except json.JSONDecodeError:
-        return 0  # malformed hook input — stay silent, never block
-
-    event = hook.get("hook_event_name") or ""
-    bin_path = _server_bin()
-    if not bin_path:
-        return 0  # server not installed — nothing to inject
-
-    project_dir = hook.get("cwd") or os.getcwd()
-    session_id = hook.get("session_id")
-
-    if event in QUERY_EVENTS:
-        # UserPromptSubmit → match the prompt. PreToolUse → match the file(s).
-        prompt = hook.get("prompt") or ""
-        tool_name = hook.get("tool_name")
-        file_paths = _file_paths_from_tool_input(hook.get("tool_input"))
-        # Text fed to BM25: the prompt for UserPromptSubmit, else the file paths
-        # (the server also adds basenames + tool_name to the query).
-        text = prompt if prompt else " ".join(file_paths)
-        arguments = {"project_dir": project_dir, "text": text}
-        if session_id:
-            arguments["session_id"] = session_id
-        if tool_name:
-            arguments["tool_name"] = tool_name
-        if file_paths:
-            arguments["file_paths"] = file_paths
-
-        payload = _call(bin_path, "handoff_memory_query", arguments)
-        if payload:
-            _emit(event, _format_memories(payload))
-        return 0
-
-    if event in CLEANUP_EVENTS:
-        # Housekeeping only: merge exact duplicates and gc sidecars. We do not
-        # inject the cleanup recommendations as context (that is for an explicit
-        # AI-driven pass), so there is no additionalContext to emit here.
-        _call(bin_path, "handoff_memory_cleanup", {"project_dir": project_dir})
-        return 0
-
-    # Unknown event — nothing to do.
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/scripts/install-local.sh

@@ -1,109 +0,0 @@
-#!/usr/bin/env bash
-# Install handoff-mcp locally: binary, skills, and plugin caches.
-# Usage: ./scripts/install-local.sh
-#
-# SCOPE: this script rebuilds the binary and refreshes the plugin CACHE only.
-# It does NOT register the marketplace (known_marketplaces.json) or enable the
-# plugin (enabledPlugins in settings.json), and it only updates
-# installed_plugins.json entries that already exist. So on a fresh machine it
-# does not activate the plugin by itself — bootstrap once with:
-#     /plugin marketplace add /absolute/path/to/handoff-mcp
-#     /plugin install handoff-mcp@handoff-mcp-marketplace
-#     /reload-plugins
-# Thereafter, re-run this script to pick up code changes, then restart Claude
-# Code (or /reload-plugins). See README "Installing the local development
-# version instead".
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(dirname "$SCRIPT_DIR")"
-CLAUDE_DIR="${HOME}/.claude"
-CACHE_DIR="${CLAUDE_DIR}/plugins/cache/handoff-mcp-marketplace"
-INSTALLED_JSON="${CLAUDE_DIR}/plugins/installed_plugins.json"
-
-cd "$ROOT"
-
-# ---------- 1. Binary ----------
-echo "==> Building release binary..."
-cargo build --release
-
-mkdir -p "${HOME}/.local/bin"
-rm -f "${HOME}/.local/bin/handoff-mcp"
-cp target/release/handoff-mcp "${HOME}/.local/bin/handoff-mcp"
-echo "    Installed: $(${HOME}/.local/bin/handoff-mcp --version)"
-
-# ---------- 2. Bundled skills ----------
-echo "==> Syncing skills..."
-skill_count=0
-for skill in skills/*/; do
-  name=$(basename "$skill")
-  mkdir -p "${CLAUDE_DIR}/skills/${name}"
-  cp "${skill}SKILL.md" "${CLAUDE_DIR}/skills/${name}/SKILL.md"
-  skill_count=$((skill_count + 1))
-done
-echo "    ${skill_count} skills synced"
-
-# ---------- 3. Sync plugin distribution skills ----------
-echo "==> Syncing plugin distribution skills..."
-"${SCRIPT_DIR}/sync-plugin-skills.sh"
-
-# ---------- 4. Plugin caches ----------
-echo "==> Syncing plugin caches..."
-
-sync_plugin() {
-  local src_dir="$1"
-  local plugin_json="${src_dir}/.claude-plugin/plugin.json"
-
-  if [ ! -f "$plugin_json" ]; then
-    echo "    SKIP: ${src_dir} (no .claude-plugin/plugin.json)"
-    return
-  fi
-
-  local name version cache_dest
-  name=$(python3 -c "import json,sys; print(json.load(sys.stdin)['name'])" < "$plugin_json")
-  version=$(python3 -c "import json,sys; print(json.load(sys.stdin)['version'])" < "$plugin_json")
-  cache_dest="${CACHE_DIR}/${name}/${version}"
-
-  rm -rf "$cache_dest"
-  mkdir -p "$cache_dest"
-
-  # Copy everything except .claude-plugin/ first, then copy .claude-plugin/
-  find "$src_dir" -mindepth 1 -maxdepth 1 -not -name '.claude-plugin' -exec cp -a {} "$cache_dest/" \;
-  cp -a "${src_dir}/.claude-plugin" "$cache_dest/.claude-plugin"
-
-  echo "    ${name}@${version} -> ${cache_dest}"
-
-  # Update installed_plugins.json timestamp
-  if [ -f "$INSTALLED_JSON" ] && command -v python3 >/dev/null 2>&1; then
-    local git_sha
-    git_sha=$(git rev-parse HEAD 2>/dev/null || echo "unknown")
-    local now
-    now=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
-    python3 -c "
-import json, sys
-key = '${name}@handoff-mcp-marketplace'
-with open('${INSTALLED_JSON}', 'r') as f:
-    data = json.load(f)
-if key in data.get('plugins', {}):
-    for entry in data['plugins'][key]:
-        entry['installPath'] = '${cache_dest}'
-        entry['version'] = '${version}'
-        entry['lastUpdated'] = '${now}'
-        entry['gitCommitSha'] = '${git_sha}'
-    with open('${INSTALLED_JSON}', 'w') as f:
-        json.dump(data, f, indent=4)
-        f.write('\n')
-" 2>/dev/null || true
-  fi
-}
-
-sync_plugin "${ROOT}/plugin"
-sync_plugin "${ROOT}/plugin-hooks"
-sync_plugin "${ROOT}/plugin-task-loop"
-
-# ---------- 5. Verify ----------
-echo ""
-echo "==> Done. Restart Claude Code to pick up changes."
-echo "    Binary:  ${HOME}/.local/bin/handoff-mcp"
-echo "    Skills:  ${CLAUDE_DIR}/skills/"
-echo "    Plugins: ${CACHE_DIR}/"

package/scripts/postinstall.js

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const { execSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const ROOT = path.resolve(__dirname, "..");
-const BIN_DIR = path.join(ROOT, "bin");
-const BINARY = path.join(BIN_DIR, "handoff-mcp-bin");
-
-if (fs.existsSync(BINARY)) {
-  try {
-    execSync(`"${BINARY}" --help`, { stdio: "ignore", timeout: 5000 });
-    process.exit(0);
-  } catch {
-    // prebuilt binary exists but can't run on this platform — rebuild
-    fs.unlinkSync(BINARY);
-  }
-}
-
-try {
-  execSync("cargo --version", { stdio: "ignore" });
-} catch {
-  console.error(
-    "Error: Rust toolchain not found.\n" +
-      "handoff-mcp-server requires Rust to build from source.\n" +
-      "Install Rust: https://rustup.rs/"
-  );
-  process.exit(1);
-}
-
-console.log("Building handoff-mcp from source...");
-try {
-  execSync("cargo build --release", { cwd: ROOT, stdio: "inherit" });
-} catch {
-  console.error("Error: cargo build failed.");
-  process.exit(1);
-}
-
-const built = path.join(ROOT, "target", "release", "handoff-mcp");
-if (!fs.existsSync(built)) {
-  console.error("Error: binary not found after build.");
-  process.exit(1);
-}
-
-fs.mkdirSync(BIN_DIR, { recursive: true });
-fs.copyFileSync(built, BINARY);
-fs.chmodSync(BINARY, 0o755);
-console.log("handoff-mcp installed successfully.");

package/scripts/sync-plugin-skills.sh

@@ -1,35 +0,0 @@
-#!/usr/bin/env bash
-# Sync skills/ -> plugin/skills/ for plugin distribution.
-#
-# plugin/skills/ is generated, but it is COMMITTED: the marketplace serves the
-# plugin straight from the repository, so a skill that is not committed there
-# never reaches an installed plugin. Run this after editing skills/, and commit
-# the result.
-#
-#   sync-plugin-skills.sh            sync skills/ -> plugin/skills/
-#   sync-plugin-skills.sh --check    exit non-zero if they differ (no writes)
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(dirname "$SCRIPT_DIR")"
-
-if [ "${1:-}" = "--check" ]; then
-  if [ ! -d "$ROOT/plugin/skills" ]; then
-    echo "ERROR: plugin/skills/ is missing. Run './scripts/sync-plugin-skills.sh'." >&2
-    exit 1
-  fi
-  if ! diff -rq "$ROOT/skills/" "$ROOT/plugin/skills/" >/dev/null 2>&1; then
-    echo "ERROR: plugin/skills/ is out of sync with skills/:" >&2
-    diff -rq "$ROOT/skills/" "$ROOT/plugin/skills/" >&2 || true
-    echo "Run './scripts/sync-plugin-skills.sh' and commit the result." >&2
-    exit 1
-  fi
-  echo "OK: plugin/skills/ is in sync with skills/."
-  exit 0
-fi
-
-rm -rf "$ROOT/plugin/skills"
-cp -a "$ROOT/skills" "$ROOT/plugin/skills"
-
-echo "Synced skills/ -> plugin/skills/"
-diff -rq "$ROOT/skills/" "$ROOT/plugin/skills/" && echo "No differences." || echo "WARNING: differences remain after sync."

package/scripts/sync-plugin-version.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# Sync plugin/marketplace manifest versions to package.json's version.
-#
-# package.json is the source of truth (kept in sync with Cargo.toml manually
-# per CLAUDE.md "Version sync" rule). This script propagates that version to:
-#   - plugin/.claude-plugin/plugin.json
-#   - plugin-hooks/.claude-plugin/plugin.json
-#   - plugin-task-loop/.claude-plugin/plugin.json
-#   - .claude-plugin/marketplace.json (all three "version" entries)
-#
-# Uses regex line replacement (not json.dump) so untouched formatting in
-# these hand-maintained manifests is preserved byte-for-byte.
-#
-# Usage:
-#   ./scripts/sync-plugin-version.sh          # fix mismatches in place
-#   ./scripts/sync-plugin-version.sh --check  # exit 1 if anything is out of sync, fix nothing
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-ROOT="$(dirname "$SCRIPT_DIR")"
-cd "$ROOT"
-
-MODE="fix"
-if [ "${1:-}" = "--check" ]; then
-  MODE="check"
-fi
-
-python3 - "$MODE" <<'PYEOF'
-import json
-import re
-import sys
-
-mode = sys.argv[1]
-
-with open("package.json") as f:
-    root_version = json.load(f)["version"]
-
-version_line_re = re.compile(r'^(\s*"version"\s*:\s*)"[^"]*"(,?\s*(?:\r?\n)?)$')
-
-def sync_file(path, mismatches):
-    with open(path) as f:
-        lines = f.readlines()
-    changed = False
-    out = []
-    for line in lines:
-        m = version_line_re.match(line)
-        if m:
-            current = re.search(r'"version"\s*:\s*"([^"]*)"', line).group(1)
-            if current != root_version:
-                mismatches.append((path, current))
-                changed = True
-                line = f'{m.group(1)}"{root_version}"{m.group(2)}'
-        out.append(line)
-    if changed and mode == "fix":
-        with open(path, "w") as f:
-            f.writelines(out)
-    return changed
-
-mismatches = []
-plugin_files = [
-    "plugin/.claude-plugin/plugin.json",
-    "plugin-hooks/.claude-plugin/plugin.json",
-    "plugin-task-loop/.claude-plugin/plugin.json",
-    ".claude-plugin/marketplace.json",
-]
-
-for path in plugin_files:
-    sync_file(path, mismatches)
-
-if mode == "check":
-    if mismatches:
-        print(f"Version mismatch: package.json is {root_version}, but found:")
-        for path, version in mismatches:
-            print(f"  {path}: {version}")
-        print("Run ./scripts/sync-plugin-version.sh to fix.")
-        sys.exit(1)
-    print(f"All plugin/marketplace manifests match package.json ({root_version}).")
-else:
-    if mismatches:
-        print(f"Synced {len(mismatches)} version occurrence(s) to {root_version}:")
-        for path, old_version in mismatches:
-            print(f"  {path}: {old_version} -> {root_version}")
-    else:
-        print(f"Already in sync at version {root_version}. No changes made.")
-PYEOF

package/scripts/sync-workflow-inline.sh

@@ -1,138 +0,0 @@
-#!/usr/bin/env bash
-#
-# sync-workflow-inline.sh — keep workflow scripts self-contained.
-#
-# The Workflow runtime cannot `import` (probed: "import() is not available in
-# workflow scripts"; `require` is undefined), and workflow scripts have a
-# top-level `return` so Node cannot import *them* either. Neither side can reach
-# the other, yet we still want the shared logic unit-tested.
-#
-# Resolution: the pure logic lives in testable ES modules (the source of truth).
-# Each module's INLINE region is mirrored verbatim into the workflow script
-# between GENERATED markers. This script performs — or verifies — that mirror.
-#
-#   ./scripts/sync-workflow-inline.sh          # rewrite the generated blocks
-#   ./scripts/sync-workflow-inline.sh --check  # fail if out of sync (CI/hook)
-#
-# Mirrors the contract of scripts/sync-plugin-version.sh.
-
-set -euo pipefail
-
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-cd "$REPO_ROOT"
-
-TARGET="plugin-task-loop/workflows/session-execute.js"
-
-# Modules mirrored into TARGET, in the order they must appear.
-# Each entry is a bare module name; source is lib/<name>.js.
-#
-# Order is load-bearing where one module's inline region calls another's:
-# `context-injection` calls resolveProfile()/profileStages() from `profile`, so
-# `profile` must be mirrored ahead of it (const bindings are in the temporal dead
-# zone until their block is evaluated).
-# `task-graph` is self-contained (pure union-find over the assignment arrays), so
-# its position is free; it sits last to keep the dependency-ordered prefix intact.
-MODULES=(verdict-logic profile context-injection task-graph)
-
-CHECK_MODE=0
-if [ "${1:-}" = "--check" ]; then
-  CHECK_MODE=1
-elif [ $# -gt 0 ]; then
-  echo "usage: $0 [--check]" >&2
-  exit 2
-fi
-
-[ -f "$TARGET" ] || { echo "ERROR: missing $TARGET" >&2; exit 1; }
-
-count_marker() { grep -cFx "$1" "$2" || true; }
-
-WORK="$(mktemp -d)"
-trap 'rm -rf "$WORK"' EXIT
-
-# Start from the current target; each module rewrites its own block in turn.
-cp "$TARGET" "$WORK/rendered"
-
-for module in "${MODULES[@]}"; do
-  SOURCE="plugin-task-loop/workflows/lib/${module}.js"
-  [ -f "$SOURCE" ] || { echo "ERROR: missing $SOURCE" >&2; exit 1; }
-
-  SRC_BEGIN="// --- BEGIN INLINE: ${module} ---"
-  SRC_END="// --- END INLINE: ${module} ---"
-  DST_BEGIN="// --- BEGIN GENERATED: ${module} (source: lib/${module}.js) ---"
-  DST_END="// --- END GENERATED: ${module} ---"
-
-  for marker in "$SRC_BEGIN" "$SRC_END"; do
-    n=$(count_marker "$marker" "$SOURCE")
-    [ "$n" -eq 1 ] || { echo "ERROR: '$marker' appears $n time(s) in $SOURCE (want 1)" >&2; exit 1; }
-  done
-  for marker in "$DST_BEGIN" "$DST_END"; do
-    n=$(count_marker "$marker" "$WORK/rendered")
-    [ "$n" -eq 1 ] || { echo "ERROR: '$marker' appears $n time(s) in $TARGET (want 1)" >&2; exit 1; }
-  done
-
-  EXTRACTED="$WORK/${module}.body"
-  awk -v b="$SRC_BEGIN" -v e="$SRC_END" '
-    $0 == b { inblk = 1; next }
-    $0 == e { inblk = 0; next }
-    inblk   { print }
-  ' "$SOURCE" > "$EXTRACTED"
-
-  if [ ! -s "$EXTRACTED" ]; then
-    echo "ERROR: extracted inline region from $SOURCE is empty" >&2
-    exit 1
-  fi
-
-  # The mirrored region must be self-contained.
-  if grep -Eq '^[[:space:]]*(import|export)[[:space:]]' "$EXTRACTED"; then
-    echo "ERROR: the inline region of $SOURCE contains import/export." >&2
-    echo "       Workflow scripts cannot import. Keep those outside the markers." >&2
-    exit 1
-  fi
-
-  # A destination marker inside the copied body would corrupt the target — the
-  # awk pass would end the generated block early and duplicate the remainder,
-  # after which every --check fails with a confusing "appears 2 time(s)".
-  for marker in "$DST_BEGIN" "$DST_END"; do
-    if grep -qFx "$marker" "$EXTRACTED"; then
-      echo "ERROR: the inline region of $SOURCE contains the destination marker:" >&2
-      echo "       $marker" >&2
-      echo "       Remove it — it would corrupt $TARGET on the next sync." >&2
-      exit 1
-    fi
-  done
-
-  awk -v b="$DST_BEGIN" -v e="$DST_END" -v body="$EXTRACTED" -v src="$SOURCE" '
-    $0 == b {
-      print
-      print "// AUTO-GENERATED — DO NOT EDIT BY HAND."
-      print "// Source: " src
-      print "// Regenerate: ./scripts/sync-workflow-inline.sh"
-      while ((getline line < body) > 0) print line
-      close(body)
-      skip = 1
-      next
-    }
-    $0 == e { skip = 0; print; next }
-    !skip   { print }
-  ' "$WORK/rendered" > "$WORK/next"
-  mv "$WORK/next" "$WORK/rendered"
-done
-
-if [ "$CHECK_MODE" -eq 1 ]; then
-  if ! diff -u "$TARGET" "$WORK/rendered" > /dev/null 2>&1; then
-    echo "ERROR: $TARGET is out of sync with its source modules" >&2
-    echo "       Run ./scripts/sync-workflow-inline.sh to regenerate." >&2
-    echo >&2
-    diff -u "$TARGET" "$WORK/rendered" >&2 || true
-    exit 1
-  fi
-  echo "OK: $TARGET is in sync with ${MODULES[*]}"
-  exit 0
-fi
-
-if diff -q "$TARGET" "$WORK/rendered" > /dev/null 2>&1; then
-  echo "OK: $TARGET already in sync (no change)"
-else
-  cat "$WORK/rendered" > "$TARGET"
-  echo "Synced: ${MODULES[*]} -> $TARGET"
-fi