@rubytech/create-maxy-code 0.1.255 → 0.1.257

package/payload/platform/plugins/admin/hooks/lib/admin-graph-pass-common.sh

@@ -1,239 +0,0 @@
-#!/usr/bin/env bash
-# Shared plumbing for the admin-side hook that orchestrates admin-walked
-# graph writes: `insight.sh` (UserPromptSubmit on the operator's `/insight`
-# token). Originally introduced (Task 439) as shared plumbing across two hooks; the
-# per-turn sibling was removed in Task 447 because session-end Pass 3 already
-# performs the graph-completeness sweep. The library is retained — its
-# stdin parse, role / specialist / transcript guards, log-ingest envelope,
-# and post-user tool-name walker are still the single body for the
-# remaining hook.
-#
-# Caller contract:
-#   1. Set `AGP_LOG_TAG` to the hook's identifying tag before sourcing.
-#      `insight` is the current value; the helper itself
-#      does not log under its own tag.
-#   2. Source this file.
-#   3. Call `agp_setup_logging`, `agp_read_stdin`, `agp_parse_stdin`,
-#      `agp_guard_role_specialist`, `agp_guard_transcript` in that order.
-#      Each guard exits 0 from inside the helper when its condition fires
-#      (sourced `exit` exits the caller).
-#   4. After the guards return, the hook proceeds with its event-specific
-#      body (sentinel-grep + intent token for session-end; post-turn-context
-#      fetch + directive envelope for pre-turn).
-#
-# Globals set by the helper (read by callers):
-#   INPUT                — raw stdin (empty when none piped)
-#   SESSION_ID           — parsed `session_id` field, empty on parse failure
-#   TRANSCRIPT_PATH      — parsed `transcript_path` field
-#   HOOK_EVENT_NAME      — parsed `hook_event_name` field
-#   SESSION_ID_REPORTED  — `$SESSION_ID` or the literal "unknown"
-#   UI_BASE              — `http://127.0.0.1:${MAXY_UI_INTERNAL_PORT}`
-#   LOG_INGEST_URL       — `${UI_BASE}/api/admin/log-ingest`
-#
-# Functions:
-#   agp_setup_logging          — resolves UI port + URLs, or exits 0 with
-#                                a stderr loud-fail when the port is unset
-#                                (fail-open so a missing port never bricks
-#                                the operator).
-#   agp_emit_log <line>        — POSTs `{tag, level:"info", line}` to
-#                                log-ingest; silent on network failure.
-#   agp_read_stdin             — slurps stdin into `INPUT`, leaves it empty
-#                                when no input is piped.
-#   agp_parse_stdin            — populates `SESSION_ID`, `TRANSCRIPT_PATH`,
-#                                `HOOK_EVENT_NAME`, `SESSION_ID_REPORTED`.
-#   agp_guard_role_specialist  — exits 0 with `trigger-skipped` log on
-#                                `role-not-admin` or `is-specialist`.
-#   agp_guard_transcript       — exits 0 with `trigger-skipped` log on
-#                                `empty-stdin` (when $1="require-stdin") or
-#                                `missing-transcript`.
-
-if [ -z "${AGP_LOG_TAG:-}" ]; then
-  echo "[admin-graph-pass-common] AGP_LOG_TAG not set by caller" >&2
-  exit 1
-fi
-
-agp_setup_logging() {
-  local ui_port="${MAXY_UI_INTERNAL_PORT:-}"
-  if [ -z "$ui_port" ]; then
-    echo "[${AGP_LOG_TAG}] trigger-skipped sessionId=unknown reason=missing-env env=MAXY_UI_INTERNAL_PORT" >&2
-    exit 0
-  fi
-  UI_BASE="http://127.0.0.1:${ui_port}"
-  LOG_INGEST_URL="${UI_BASE}/api/admin/log-ingest"
-}
-
-agp_emit_log() {
-  local line="$1"
-  curl -sS -o /dev/null -X POST \
-    -H 'Content-Type: application/json' \
-    --max-time 2 \
-    --data "$(AGP_TAG="$AGP_LOG_TAG" AGP_LINE="$line" python3 -c '
-import os, json
-print(json.dumps({"tag": os.environ["AGP_TAG"], "level": "info", "line": os.environ["AGP_LINE"]}))
-')" \
-    "$LOG_INGEST_URL" 2>/dev/null || true
-}
-
-agp_read_stdin() {
-  INPUT=""
-  if [ ! -t 0 ]; then
-    INPUT=$(cat)
-  fi
-}
-
-agp_parse_stdin() {
-  local parsed
-  parsed=$(printf '%s' "$INPUT" | python3 -c '
-import sys, json
-try:
-    d = json.load(sys.stdin)
-    sid = d.get("session_id", "") or ""
-    tpath = d.get("transcript_path", "") or ""
-    event = d.get("hook_event_name", "") or ""
-    print(f"{sid}\t{tpath}\t{event}")
-except Exception:
-    print("\t\t")
-' 2>/dev/null)
-  SESSION_ID="${parsed%%	*}"
-  local rest="${parsed#*	}"
-  TRANSCRIPT_PATH="${rest%%	*}"
-  HOOK_EVENT_NAME="${rest#*	}"
-  SESSION_ID_REPORTED="${SESSION_ID:-unknown}"
-}
-
-agp_guard_role_specialist() {
-  if [ "${MAXY_SESSION_ROLE:-}" != "admin" ]; then
-    agp_emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=role-not-admin"
-    exit 0
-  fi
-  # Recursion guard. A specialist subagent dispatched via the Task tool
-  # (e.g. database-operator running the operator's graph writes) carries
-  # `MAXY_SPECIALIST=<name>` on the PTY env. Skip — the hooks only fire
-  # for the operator's own admin session.
-  #
-  # Invariant the PTY spawner is expected to honour: `MAXY_SPECIALIST` is
-  # either set to a non-empty specialist name OR absent. An explicit empty
-  # string from a wrapper would slip the recursion guard here (`-n ""` is
-  # false) — that would be a defect at the spawn site, not here.
-  if [ -n "${MAXY_SPECIALIST:-}" ]; then
-    agp_emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=is-specialist specialist=${MAXY_SPECIALIST}"
-    exit 0
-  fi
-}
-
-# Usage: agp_guard_transcript [require-stdin]
-# Pass `require-stdin` (insight.sh) to emit `empty-stdin` on a
-# blank `INPUT`. Without the flag, parse failure on a non-empty INPUT
-# collapses to `missing-transcript` cleanly.
-agp_guard_transcript() {
-  if [ "${1:-}" = "require-stdin" ] && [ -z "$INPUT" ]; then
-    agp_emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=empty-stdin"
-    exit 0
-  fi
-  if [ -z "$SESSION_ID" ] || [ -z "$TRANSCRIPT_PATH" ] || [ ! -f "$TRANSCRIPT_PATH" ]; then
-    agp_emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=missing-transcript"
-    exit 0
-  fi
-}
-
-# Walks $TRANSCRIPT_PATH and reports, in one line on stdout:
-#   <real-user-present:yes|no>\t<matched-tool-name-or-empty>
-# A "real user" record matches `insight.sh`'s `is_real_user`
-# — `type=user, message.role=user`, content is a string OR a list with at
-# least one non-`tool_result` block. `tool_result`-only user records are tool
-# replies, never turn starts.
-#
-# Every assistant `tool_use` block that appears AFTER the latest real-user
-# record is matched against the alternation passed as `$1` (an extended-regex
-# alternation of literal `tool_use.name` values). The synthetic name
-# `Task:<subagent_type>` is also matched, so callers can release on a
-# `Task` tool_use with `input.subagent_type=<name>` by including
-# `Task:<name>` in the alternation. Returns the first match encountered after
-# the latest real-user record (oldest-first) so the release log carries the
-# matched tool's actual name. Empty match means none of the release patterns
-# appeared since the operator's last turn.
-agp_scan_post_user_toolnames() {
-  local pattern="$1"
-  TRANSCRIPT_PATH="$TRANSCRIPT_PATH" AGP_PATTERN="$pattern" python3 - <<'PY'
-import os, json, re
-
-pattern = re.compile(os.environ["AGP_PATTERN"])
-path = os.environ["TRANSCRIPT_PATH"]
-
-def is_real_user(rec):
-    if not isinstance(rec, dict) or rec.get("type") != "user":
-        return False
-    msg = rec.get("message")
-    if not isinstance(msg, dict) or msg.get("role") != "user":
-        return False
-    content = msg.get("content")
-    if isinstance(content, str):
-        return True
-    if isinstance(content, list):
-        for b in content:
-            if isinstance(b, dict) and b.get("type") != "tool_result":
-                return True
-        return False
-    return True
-
-def assistant_tool_use_names(rec):
-    if not isinstance(rec, dict) or rec.get("type") != "assistant":
-        return []
-    msg = rec.get("message", {}) or {}
-    if msg.get("role") != "assistant":
-        return []
-    content = msg.get("content")
-    if not isinstance(content, list):
-        return []
-    names = []
-    for b in content:
-        if isinstance(b, dict) and b.get("type") == "tool_use":
-            n = b.get("name")
-            if not isinstance(n, str):
-                continue
-            names.append(n)
-            if n == "Task":
-                inp = b.get("input")
-                if isinstance(inp, dict):
-                    st = inp.get("subagent_type")
-                    if isinstance(st, str) and st:
-                        names.append(f"Task:{st}")
-    return names
-
-records = []
-try:
-    with open(path, "r", encoding="utf-8") as f:
-        for raw in f:
-            raw = raw.strip()
-            if not raw:
-                continue
-            try:
-                records.append(json.loads(raw))
-            except Exception:
-                continue
-except Exception:
-    print("no\t")
-    raise SystemExit(0)
-
-latest_user_idx = -1
-for i in range(len(records) - 1, -1, -1):
-    if is_real_user(records[i]):
-        latest_user_idx = i
-        break
-
-if latest_user_idx == -1:
-    print("no\t")
-    raise SystemExit(0)
-
-matched = ""
-for r in records[latest_user_idx + 1:]:
-    for n in assistant_tool_use_names(r):
-        if pattern.fullmatch(n):
-            matched = n
-            break
-    if matched:
-        break
-
-print(f"yes\t{matched}")
-PY
-}

package/payload/premium-plugins/writer-craft/hooks/__tests__/voice-session-end-text.test.sh

@@ -1,284 +0,0 @@
-#!/usr/bin/env bash
-# voice-session-end-text.sh hook test suite.
-#
-# Pattern: a local Python HTTP server stands in for /api/admin/log-ingest
-# and records every POST so the assertions can inspect every log line the
-# hook emitted. The CLI is stubbed with a mock node script so tests run
-# without a live Neo4j connection.
-#
-# Contract under test:
-#   - Hook skips with reason=role-not-admin when MAXY_SESSION_ROLE != admin.
-#   - Hook skips with reason=is-specialist when MAXY_SPECIALIST is set.
-#   - Hook skips with reason=empty-stdin when no stdin is piped.
-#   - Hook skips with reason=missing-transcript when the JSONL path in the
-#     stdin envelope does not exist.
-#   - Hook skips with reason=cli-not-found when the compiled CLI is absent.
-#   - Happy path: hook emits trigger + result=ok when all guards pass and the
-#     stub CLI exits 0.
-#   - Dedupe path: stub CLI returns turns=0 skipped=3 → result=ok with those
-#     counts (verifying the hook forwards the CLI stdout to the log-ingest).
-
-set -u
-
-HOOK="$(cd "$(dirname "$0")/.." && pwd)/voice-session-end-text.sh"
-if [[ ! -f "$HOOK" ]]; then
-  echo "FAIL: hook not found at $HOOK" >&2
-  exit 1
-fi
-
-PASS=0
-FAIL=0
-TMPFILES=()
-LISTENER_PIDS=()
-
-cleanup() {
-  for pid in "${LISTENER_PIDS[@]:-}"; do
-    [[ -n "$pid" ]] && { kill "$pid" 2>/dev/null || true; wait "$pid" 2>/dev/null || true; }
-  done
-  for f in "${TMPFILES[@]:-}"; do
-    [[ -n "$f" ]] && rm -f "$f" 2>/dev/null || true
-  done
-}
-trap cleanup EXIT
-
-# ---- helpers ---------------------------------------------------------------
-
-make_tmp_file() {
-  local tmp
-  tmp=$(mktemp)
-  TMPFILES+=("$tmp")
-  echo "$tmp"
-}
-
-# Start a listener on a random port; capture every POST body.
-# Sets LISTENER_PORT and LISTENER_LOG globals.
-start_listener() {
-  LISTENER_LOG=$(make_tmp_file)
-  LISTENER_PORT=$(python3 -c 'import socket; s=socket.socket(); s.bind(("",0)); print(s.getsockname()[1]); s.close()')
-  python3 - "$LISTENER_PORT" "$LISTENER_LOG" <<'PY' &
-import sys, http.server, json
-
-port = int(sys.argv[1])
-log  = sys.argv[2]
-
-class H(http.server.BaseHTTPRequestHandler):
-    def do_POST(self):
-        n = int(self.headers.get("Content-Length", 0))
-        body = self.rfile.read(n).decode()
-        with open(log, "a") as f:
-            f.write(body + "\n")
-        self.send_response(200)
-        self.end_headers()
-    def log_message(self, *a): pass
-
-http.server.HTTPServer(("127.0.0.1", port), H).serve_forever()
-PY
-  local pid=$!
-  LISTENER_PIDS+=("$pid")
-  sleep 0.3   # let the server start
-}
-
-# Run the hook with given env overrides and optional stdin.
-# Returns: HOOK_EXIT, LISTENER_LINES (array of log-ingest line bodies).
-run_hook() {
-  local env_args=("$@")
-  local stdin_data="${HOOK_STDIN:-}"
-  local hook_exit=0
-  if [[ -n "$stdin_data" ]]; then
-    printf '%s' "$stdin_data" | env \
-      MAXY_UI_INTERNAL_PORT="$LISTENER_PORT" \
-      MAXY_SESSION_ROLE="${MAXY_SESSION_ROLE:-admin}" \
-      MAXY_SPECIALIST="${MAXY_SPECIALIST:-}" \
-      PLATFORM_ROOT="${FAKE_PLATFORM_ROOT:-}" \
-      ACCOUNT_ID="${ACCOUNT_ID:-acct-test}" \
-      USER_ID="${USER_ID:-user-test}" \
-      SESSION_ID="" \
-      NEO4J_URI="bolt://localhost:7688" \
-      NEO4J_USER="neo4j" \
-      NEO4J_PASSWORD="test" \
-      ${env_args[@]+"${env_args[@]}"} \
-      bash "$HOOK" >/dev/null 2>/dev/null || hook_exit=$?
-  else
-    env \
-      MAXY_UI_INTERNAL_PORT="$LISTENER_PORT" \
-      MAXY_SESSION_ROLE="${MAXY_SESSION_ROLE:-admin}" \
-      MAXY_SPECIALIST="${MAXY_SPECIALIST:-}" \
-      PLATFORM_ROOT="${FAKE_PLATFORM_ROOT:-}" \
-      ACCOUNT_ID="${ACCOUNT_ID:-acct-test}" \
-      USER_ID="${USER_ID:-user-test}" \
-      SESSION_ID="" \
-      NEO4J_URI="bolt://localhost:7688" \
-      NEO4J_USER="neo4j" \
-      NEO4J_PASSWORD="test" \
-      ${env_args[@]+"${env_args[@]}"} \
-      bash "$HOOK" </dev/null >/dev/null 2>/dev/null || hook_exit=$?
-  fi
-  HOOK_EXIT=$hook_exit
-  # Read all log-ingest POSTs.
-  LISTENER_LINES=()
-  while IFS= read -r raw; do
-    [[ -z "$raw" ]] && continue
-    LISTENER_LINES+=("$raw")
-  done < "$LISTENER_LOG"
-  # Reset log for next run.
-  > "$LISTENER_LOG"
-}
-
-assert_contains_line() {
-  local test_name="$1"
-  local fragment="$2"
-  for line in "${LISTENER_LINES[@]:-}"; do
-    if [[ "$line" == *"$fragment"* ]]; then
-      echo "  PASS: $test_name"
-      PASS=$((PASS + 1))
-      return 0
-    fi
-  done
-  echo "  FAIL: $test_name (expected fragment: '$fragment' not found in log lines)"
-  printf '       lines:\n'
-  for line in "${LISTENER_LINES[@]:-}"; do printf '         %s\n' "$line"; done
-  FAIL=$((FAIL + 1))
-}
-
-assert_exit() {
-  local test_name="$1"
-  local expected="$2"
-  if [[ "$HOOK_EXIT" -eq "$expected" ]]; then
-    echo "  PASS: $test_name (exit $expected)"
-    PASS=$((PASS + 1))
-  else
-    echo "  FAIL: $test_name (expected exit $expected, got $HOOK_EXIT)"
-    FAIL=$((FAIL + 1))
-  fi
-}
-
-# ---- setup -----------------------------------------------------------------
-
-start_listener
-
-# Create a fake platform root structure so the lib source works.
-FAKE_PLATFORM_ROOT=$(mktemp -d)
-TMPFILES+=("$FAKE_PLATFORM_ROOT")
-mkdir -p "$FAKE_PLATFORM_ROOT/plugins/admin/hooks/lib"
-# Copy the real lib so guards work correctly.
-REAL_LIB="$(cd "$(dirname "$0")/../../../../platform/plugins/admin/hooks/lib" && pwd)/admin-graph-pass-common.sh"
-if [[ ! -f "$REAL_LIB" ]]; then
-  echo "FAIL: admin-graph-pass-common.sh not found at $REAL_LIB" >&2
-  exit 1
-fi
-cp "$REAL_LIB" "$FAKE_PLATFORM_ROOT/plugins/admin/hooks/lib/admin-graph-pass-common.sh"
-
-# Create a minimal fake JSONL transcript.
-FAKE_TRANSCRIPT=$(make_tmp_file)
-printf '{"type":"user","message":{"role":"user","content":"Hello world"}}\n' > "$FAKE_TRANSCRIPT"
-
-# Create a stub CLI that exits 0 with a canned result.
-FAKE_CLI_DIR=$(mktemp -d)
-TMPFILES+=("$FAKE_CLI_DIR")
-STUB_CLI="$FAKE_CLI_DIR/ingest-session-text.js"
-cat > "$STUB_CLI" <<'STUB'
-process.stdout.write("turns=3 skipped=0 sessionId=test-session\n");
-process.exit(0);
-STUB
-
-# Stub CLI for dedupe scenario (turns=0).
-STUB_CLI_DEDUP="$FAKE_CLI_DIR/ingest-dedup.js"
-cat > "$STUB_CLI_DEDUP" <<'STUB'
-process.stdout.write("turns=0 skipped=3 sessionId=test-session\n");
-process.exit(0);
-STUB
-
-# Stub CLI that exits 1 (error).
-STUB_CLI_ERR="$FAKE_CLI_DIR/ingest-error.js"
-cat > "$STUB_CLI_ERR" <<'STUB'
-process.stderr.write("simulated error\n");
-process.exit(1);
-STUB
-
-# Valid stdin envelope for the SessionEnd hook.
-valid_envelope() {
-  local transcript="${1:-$FAKE_TRANSCRIPT}"
-  printf '{"session_id":"test-session","transcript_path":"%s","hook_event_name":"SessionEnd"}' "$transcript"
-}
-
-# Override CLI path by symlinking ingest-session-text.js inside a fake platform layout.
-make_platform_with_cli() {
-  local stub="$1"
-  local proot
-  proot=$(mktemp -d)
-  TMPFILES+=("$proot")
-  cp "$FAKE_PLATFORM_ROOT/plugins/admin/hooks/lib/admin-graph-pass-common.sh" \
-     "$proot/plugins/admin/hooks/lib/" 2>/dev/null || \
-     { mkdir -p "$proot/plugins/admin/hooks/lib"; cp "$REAL_LIB" "$proot/plugins/admin/hooks/lib/admin-graph-pass-common.sh"; }
-  mkdir -p "$proot/../premium-plugins/writer-craft/mcp/dist/cli" 2>/dev/null || \
-    mkdir -p "$(dirname "$proot")/../premium-plugins/writer-craft/mcp/dist/cli" 2>/dev/null || true
-  # Simpler: build the expected path from $PLATFORM_ROOT/../premium-plugins/...
-  # The hook computes: ${PLATFORM_ROOT}/../premium-plugins/writer-craft/mcp/dist/cli/ingest-session-text.js
-  # So parent of $proot + /premium-plugins/writer-craft/mcp/dist/cli/
-  local parent
-  parent=$(dirname "$proot")
-  mkdir -p "$parent/premium-plugins/writer-craft/mcp/dist/cli"
-  cp "$stub" "$parent/premium-plugins/writer-craft/mcp/dist/cli/ingest-session-text.js"
-  echo "$proot"
-}
-
-# ---- tests -----------------------------------------------------------------
-echo "[voice-session-end-text.test] starting"
-
-# T1: non-admin role → skip
-MAXY_SESSION_ROLE="public" HOOK_STDIN=$(valid_envelope) run_hook
-assert_exit "T1: non-admin exits 0" 0
-assert_contains_line "T1: non-admin emits trigger-skipped" "trigger-skipped"
-
-# T2: specialist → skip
-unset MAXY_SESSION_ROLE 2>/dev/null || true
-MAXY_SESSION_ROLE="admin" MAXY_SPECIALIST="database-operator" HOOK_STDIN=$(valid_envelope) run_hook
-assert_exit "T2: specialist exits 0" 0
-assert_contains_line "T2: specialist emits trigger-skipped" "trigger-skipped"
-
-# T3: empty stdin → skip
-MAXY_SPECIALIST="" MAXY_SESSION_ROLE="admin"
-HOOK_STDIN="" run_hook   # no stdin piped
-assert_exit "T3: empty-stdin exits 0" 0
-assert_contains_line "T3: empty-stdin emits trigger-skipped" "trigger-skipped"
-
-# T4: missing transcript → skip
-FAKE_MISSING=$(make_tmp_file)
-rm -f "$FAKE_MISSING"
-HOOK_STDIN=$(valid_envelope "$FAKE_MISSING") run_hook
-assert_exit "T4: missing-transcript exits 0" 0
-assert_contains_line "T4: missing-transcript emits trigger-skipped" "trigger-skipped"
-
-# T5: CLI not found → skip
-FAKE_PLATFORM_ROOT="$FAKE_PLATFORM_ROOT" HOOK_STDIN=$(valid_envelope) run_hook
-assert_exit "T5: cli-not-found exits 0" 0
-assert_contains_line "T5: cli-not-found emits trigger-skipped" "cli-not-found"
-
-# T6: happy path — stub CLI exits 0
-HAPPY_PROOT=$(make_platform_with_cli "$STUB_CLI")
-FAKE_PLATFORM_ROOT="$HAPPY_PROOT" HOOK_STDIN=$(valid_envelope) run_hook
-assert_exit "T6: happy path exits 0" 0
-assert_contains_line "T6: happy path emits trigger" "trigger"
-assert_contains_line "T6: happy path emits result=ok" "result=ok"
-
-# T7: dedupe — stub returns turns=0 skipped=3
-DEDUP_PROOT=$(make_platform_with_cli "$STUB_CLI_DEDUP")
-FAKE_PLATFORM_ROOT="$DEDUP_PROOT" HOOK_STDIN=$(valid_envelope) run_hook
-assert_exit "T7: dedupe exits 0" 0
-assert_contains_line "T7: dedupe emits result=ok" "result=ok"
-
-# T8: CLI error — stub exits 1
-ERR_PROOT=$(make_platform_with_cli "$STUB_CLI_ERR")
-FAKE_PLATFORM_ROOT="$ERR_PROOT" HOOK_STDIN=$(valid_envelope) run_hook
-assert_exit "T8: cli-error exits 0" 0
-assert_contains_line "T8: cli-error emits result=err" "result=err"
-
-# ---- summary ---------------------------------------------------------------
-echo ""
-if [[ "$FAIL" -eq 0 ]]; then
-  echo "[voice-session-end-text.test] all $PASS tests passed"
-  exit 0
-else
-  echo "[voice-session-end-text.test] FAILED — $FAIL/$((PASS + FAIL)) tests failed"
-  exit 1
-fi

package/payload/premium-plugins/writer-craft/hooks/voice-session-end-text.sh

@@ -1,75 +0,0 @@
-#!/usr/bin/env bash
-# SessionEnd hook — auto-ingests operator PTY turns as :Message {format:'text'}
-# corpus nodes in the writer-craft voice corpus.
-#
-# Fired by Claude Code after each PTY session terminates. Receives the full
-# session envelope from stdin:
-#   { "session_id": "...", "transcript_path": "...", "hook_event_name": "SessionEnd", ... }
-#
-# Guards (shared logic via admin-graph-pass-common.sh):
-#   - role != admin     → exit 0 (trigger-skipped reason=role-not-admin)
-#   - MAXY_SPECIALIST set → exit 0 (trigger-skipped reason=is-specialist)
-#   - empty stdin       → exit 0 (trigger-skipped reason=empty-stdin)
-#   - missing transcript → exit 0 (trigger-skipped reason=missing-transcript)
-#
-# Additional guard:
-#   - CLI not found     → exit 0 (trigger-skipped reason=cli-not-found)
-#     Graceful: accounts without writer-craft installed skip silently.
-#
-# Environment (inherited from PTY spawn — set by session manager systemd unit):
-#   PLATFORM_ROOT    — used to locate the admin hooks lib and the CLI
-#   ACCOUNT_ID       — operator's account identifier
-#   USER_ID          — operator's userId
-#   SESSION_ID       — parsed from stdin envelope by agp_parse_stdin
-#   NEO4J_URI        — bolt URI (propagated from systemd unit env)
-#   NEO4J_USER       — neo4j username
-#   NEO4J_PASSWORD   — neo4j password
-#
-# Observability:
-#   [voice-session-end-hook] trigger-skipped sessionId=<id> reason=<reason>
-#   [voice-session-end-hook] trigger sessionId=<id>
-#   [voice-session-end-hook] result=ok sessionId=<id> turns=<n> skipped=<m>
-#   [voice-session-end-hook] result=err sessionId=<id> reason=<detail>
-
-set -uo pipefail
-
-AGP_LOG_TAG="voice-session-end-hook"
-
-# Locate the shared plumbing library via PLATFORM_ROOT (set at PTY spawn).
-# This is more robust than a relative path from the hook's own directory.
-AGP_LIB="${PLATFORM_ROOT:-}/plugins/admin/hooks/lib/admin-graph-pass-common.sh"
-if [ ! -f "$AGP_LIB" ]; then
-  echo "[${AGP_LOG_TAG}] trigger-skipped sessionId=unknown reason=missing-helper path=${AGP_LIB}" >&2
-  exit 0
-fi
-# shellcheck source=../../../platform/plugins/admin/hooks/lib/admin-graph-pass-common.sh
-source "$AGP_LIB"
-
-agp_setup_logging
-agp_read_stdin
-agp_parse_stdin
-agp_guard_role_specialist
-agp_guard_transcript require-stdin
-
-# Locate the ingest CLI. Built alongside the MCP server — lives in dist/cli/.
-CLI_PATH="${PLATFORM_ROOT:-}/../premium-plugins/writer-craft/mcp/dist/cli/ingest-session-text.js"
-if [ ! -f "$CLI_PATH" ]; then
-  agp_emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=cli-not-found path=${CLI_PATH}"
-  exit 0
-fi
-
-agp_emit_log "trigger sessionId=${SESSION_ID_REPORTED}"
-
-# Invoke the CLI. All required context is in the inherited env:
-#   ACCOUNT_ID, USER_ID, NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD
-# SESSION_ID is passed explicitly since agp_parse_stdin sets it from stdin.
-result=$(SESSION_ID="${SESSION_ID}" node "$CLI_PATH" "$TRANSCRIPT_PATH" 2>&1)
-exit_code=$?
-
-if [ "$exit_code" -eq 0 ]; then
-  agp_emit_log "result=ok sessionId=${SESSION_ID_REPORTED} ${result}"
-else
-  agp_emit_log "result=err sessionId=${SESSION_ID_REPORTED} reason=${result}"
-fi
-
-exit 0

package/payload/premium-plugins/writer-craft/mcp/src/cli/ingest-session-text.ts

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-/**
- * CLI wrapper for voice-ingest-session-text.
- *
- * Invoked by the SessionEnd hook after each admin PTY session:
- *   node dist/cli/ingest-session-text.js <transcript_path>
- *
- * All other parameters are read from environment variables inherited from
- * the PTY session (which inherits from the session manager's systemd unit):
- *
- *   ACCOUNT_ID    — operator's account identifier
- *   USER_ID       — operator's userId (= adminUserId)
- *   SESSION_ID    — session identifier (parsed by hook from stdin)
- *   NEO4J_URI     — neo4j bolt URI
- *   NEO4J_USER    — neo4j username
- *   NEO4J_PASSWORD — neo4j password
- *
- * Exit codes:
- *   0 — success (includes no-new-turns case)
- *   1 — error (missing required env, JSONL not found, DB error)
- *
- * stdout: one-line result summary ("turns=N skipped=M") for the hook to
- * capture and forward to the log-ingest endpoint.
- * stderr: detailed diagnostics (tool log lines).
- */
-import { voiceIngestSessionText } from "../tools/voice-ingest-session-text.js";
-import { closeDriver } from "../lib/neo4j.js";
-
-const transcriptPath = process.argv[2];
-if (!transcriptPath) {
-  process.stderr.write("[ingest-session-text] error: transcript path required as argv[2]\n");
-  process.exit(1);
-}
-
-const accountId = process.env.ACCOUNT_ID ?? "";
-const userId = process.env.USER_ID ?? "";
-const sessionId = process.env.SESSION_ID ?? undefined;
-
-if (!accountId || !userId) {
-  process.stderr.write(
-    `[ingest-session-text] error: ACCOUNT_ID and USER_ID must be set in env (accountId=${accountId || "empty"} userId=${userId || "empty"})\n`,
-  );
-  process.exit(1);
-}
-
-try {
-  const result = await voiceIngestSessionText({
-    sessionJsonlPath: transcriptPath,
-    accountId,
-    userId,
-    sessionId,
-  });
-  // Emit one-line summary to stdout for the hook to capture.
-  process.stdout.write(
-    `turns=${result.ingestedCount} skipped=${result.skippedCount} sessionId=${result.sessionId ?? "unknown"}\n`,
-  );
-  process.exit(0);
-} catch (err) {
-  process.stderr.write(
-    `[ingest-session-text] error: ${err instanceof Error ? err.message : String(err)}\n`,
-  );
-  process.exit(1);
-} finally {
-  await closeDriver();
-}