@rubytech/create-maxy-code 0.1.114 → 0.1.116

package/dist/__tests__/installer-specialist-registration.test.js

@@ -7,7 +7,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, readlinkSync, lstatSync, rmSync, symlinkSync, readdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import { registerSpecialistAgentsAt, SpecialistSymlinkCollision } from "../specialist-registration.js";
+import { registerSpecialistAgentsAt, registerPremiumBundleAgents, SpecialistSymlinkCollision } from "../specialist-registration.js";
 function makeTemplates(dir, names) {
     mkdirSync(dir, { recursive: true });
     for (const n of names)
@@ -90,6 +90,45 @@ test("skips with reason=no-templates-dir when templates dir is absent", () => {
         rmSync(agentsDir, { recursive: true, force: true });
     }
 });
+// Task 349 — premium-bundle agents must be symlinked into the same
+// $CLAUDE_CONFIG_DIR/agents/ as base specialists. Pre-349, the installer
+// shipped premium-plugins/<bundle>/agents/*.md files in the payload but never
+// wired them in, so `--agent listing-curator` (and the rest of the realagent
+// quartet) threw `specialist-agent-file-missing` at spawn time.
+test("premium bundle: symlinks each agent in the bundle's agents/ into agentsDir", () => {
+    const installDir = mkdtempSync(join(tmpdir(), "t349-install-"));
+    const agentsDir = mkdtempSync(join(tmpdir(), "t349-agents-"));
+    try {
+        const bundleAgentsDir = join(installDir, "premium-plugins", "real-agent", "agents");
+        makeTemplates(bundleAgentsDir, ["listing-curator", "negotiator", "valuer", "compliance"]);
+        const result = registerPremiumBundleAgents(installDir, ["real-agent"], agentsDir);
+        assert.deepEqual(result.bundles, ["real-agent"]);
+        for (const n of ["listing-curator", "negotiator", "valuer", "compliance"]) {
+            const linkPath = join(agentsDir, `${n}.md`);
+            const stat = lstatSync(linkPath);
+            assert.ok(stat.isSymbolicLink(), `${n}.md must be a symlink`);
+            const target = resolve(agentsDir, readlinkSync(linkPath));
+            assert.equal(target, resolve(bundleAgentsDir, `${n}.md`));
+        }
+    }
+    finally {
+        rmSync(installDir, { recursive: true, force: true });
+        rmSync(agentsDir, { recursive: true, force: true });
+    }
+});
+test("premium bundle: empty bundle list is a no-op — no error, no writes", () => {
+    const installDir = mkdtempSync(join(tmpdir(), "t349-install-"));
+    const agentsDir = mkdtempSync(join(tmpdir(), "t349-agents-"));
+    try {
+        const result = registerPremiumBundleAgents(installDir, [], agentsDir);
+        assert.deepEqual(result.bundles, []);
+        assert.deepEqual(readdirSync(agentsDir), []);
+    }
+    finally {
+        rmSync(installDir, { recursive: true, force: true });
+        rmSync(agentsDir, { recursive: true, force: true });
+    }
+});
 test("collides loudly on a regular file at the destination (no silent overwrite)", () => {
     const templatesDir = mkdtempSync(join(tmpdir(), "t165-tpl-"));
     const agentsDir = mkdtempSync(join(tmpdir(), "t165-agents-"));

package/dist/__tests__/premium-bundle-gate.test.js

@@ -0,0 +1,59 @@
+// Tests for the brand-level premium bundle gate (Task 344).
+//
+// The gate normalises `brand.shipsPremiumBundles` and partitions the
+// on-disk bundle list into shipped/skipped/missing. The bundle.js script
+// uses it; tests are ephemeral per the sprint workflow.
+import test from "node:test";
+import assert from "node:assert/strict";
+// @ts-expect-error - sibling .mjs without type declarations
+import { normalisePremiumGate, partitionBundles } from "../../scripts/premium-bundle-gate.mjs";
+test("normalisePremiumGate: undefined → mode 'none'", () => {
+    const gate = normalisePremiumGate(undefined);
+    assert.equal(gate.mode, "none");
+    assert.equal(gate.allow.size, 0);
+});
+test("normalisePremiumGate: null → mode 'none'", () => {
+    const gate = normalisePremiumGate(null);
+    assert.equal(gate.mode, "none");
+});
+test("normalisePremiumGate: string[] → mode 'allowlist'", () => {
+    const gate = normalisePremiumGate(["real-agent", "venture-studio"]);
+    assert.equal(gate.mode, "allowlist");
+    assert.ok(gate.allow.has("real-agent"));
+    assert.ok(gate.allow.has("venture-studio"));
+});
+test("normalisePremiumGate: boolean true is rejected (legacy form)", () => {
+    assert.throws(() => normalisePremiumGate(true, "/brands/x/brand.json"), /boolean 'true' no longer accepted/);
+});
+test("normalisePremiumGate: boolean false is rejected (must omit instead)", () => {
+    assert.throws(() => normalisePremiumGate(false, "/brands/x/brand.json"), /boolean 'false' no longer accepted/);
+});
+test("normalisePremiumGate: non-array non-bool throws", () => {
+    assert.throws(() => normalisePremiumGate("real-agent"));
+    assert.throws(() => normalisePremiumGate({}));
+});
+test("normalisePremiumGate: array with non-kebab entry throws", () => {
+    assert.throws(() => normalisePremiumGate(["Real-Agent"]), /invalid entry/);
+    assert.throws(() => normalisePremiumGate([""]), /invalid entry/);
+    assert.throws(() => normalisePremiumGate([42]), /invalid entry/);
+});
+test("partitionBundles: mode 'none' ships nothing; everything on disk is skipped", () => {
+    const gate = normalisePremiumGate(undefined);
+    const result = partitionBundles(gate, ["real-agent", "venture-studio"]);
+    assert.deepEqual(result.shipped, []);
+    assert.deepEqual(result.skipped, ["real-agent", "venture-studio"]);
+    assert.deepEqual(result.missing, []);
+});
+test("partitionBundles: allowlist filters on-disk set", () => {
+    const gate = normalisePremiumGate(["venture-studio"]);
+    const result = partitionBundles(gate, ["real-agent", "teaching", "venture-studio", "writer-craft"]);
+    assert.deepEqual(result.shipped, ["venture-studio"]);
+    assert.deepEqual(result.skipped, ["real-agent", "teaching", "writer-craft"]);
+    assert.deepEqual(result.missing, []);
+});
+test("partitionBundles: allowlist entry with no matching directory is missing", () => {
+    const gate = normalisePremiumGate(["real-agent", "nope"]);
+    const result = partitionBundles(gate, ["real-agent", "teaching"]);
+    assert.deepEqual(result.shipped, ["real-agent"]);
+    assert.deepEqual(result.missing, ["nope"]);
+});

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync, cpSync, readFileSync, rmSync, readdirSync, appendFileSync, openSync, closeSync, chmodSync, statSync, realpathSync } from "node:fs";
-import { registerSpecialistAgentsAt, SpecialistSymlinkCollision } from "./specialist-registration.js";
+import { registerSpecialistAgentsAt, registerPremiumBundleAgents, SpecialistSymlinkCollision } from "./specialist-registration.js";
 import { resolve, join, dirname } from "node:path";
 import { randomBytes } from "node:crypto";
 import { resolveInstallPortFromFs, buildMaxyUnitFile, buildClaudeSessionManagerUnitFile, buildClaudePtysSliceUnitFile } from "./port-resolution.js";
@@ -2456,6 +2456,12 @@ function writeEntitlementFromFlag(payload) {
 function registerSpecialistAgents() {
     try {
         registerSpecialistAgentsAt(join(INSTALL_DIR, "platform/templates/specialists/agents"), join(CLAUDE_CONFIG_DIR, "agents"), (line) => { console.log(line); logFile(line); });
+        // Task 349 — symlink each premium-bundle's agents/ into the same
+        // $CLAUDE_CONFIG_DIR/agents/ so `--agent <name>` resolves for premium
+        // specialists (e.g. realagent's listing-curator, negotiator, valuer,
+        // compliance). The pty-spawner reads exactly one agents dir; the bundle
+        // payload alone is insufficient without the symlink step here.
+        registerPremiumBundleAgents(INSTALL_DIR, resolvePremiumBundles(), join(CLAUDE_CONFIG_DIR, "agents"), (line) => { console.log(line); logFile(line); });
     }
     catch (err) {
         if (err instanceof SpecialistSymlinkCollision) {
@@ -2466,6 +2472,23 @@ function registerSpecialistAgents() {
         throw err;
     }
 }
+// Resolve the brand's premium-bundle list for installer-side iteration.
+// `true` widens to every directory under <INSTALL_DIR>/premium-plugins/;
+// an explicit array is used verbatim; absent/false → no premium bundles.
+function resolvePremiumBundles() {
+    const ships = BRAND.shipsPremiumBundles;
+    if (Array.isArray(ships))
+        return ships;
+    if (ships === true) {
+        const root = join(INSTALL_DIR, "premium-plugins");
+        if (!existsSync(root))
+            return [];
+        return readdirSync(root, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    return [];
+}
 // ---------------------------------------------------------------------------
 // Account discovery (shared by installService + the post-install summary)
 //

package/dist/specialist-registration.js

@@ -47,6 +47,21 @@ export function registerSpecialistAgentsAt(templatesDir, agentsDir, log = () =>
     }
     return { registered, skipped: null };
 }
+// Task 349 — premium-bundle specialist symlinking. The installer wires each
+// brand-shipped premium bundle's `agents/` directory into the same
+// $CLAUDE_CONFIG_DIR/agents/ so `--agent <name>` resolves for premium
+// specialists (e.g. realagent's listing-curator). `bundles` is the resolved
+// list of bundle directory names; an empty list is a no-op (no error, no
+// writes). Missing per-bundle `agents/` dirs are tolerated via
+// registerSpecialistAgentsAt's existing no-templates-dir skip.
+export function registerPremiumBundleAgents(installDir, bundles, agentsDir, log = () => { }) {
+    const registered = [];
+    for (const bundle of bundles) {
+        registerSpecialistAgentsAt(join(installDir, "premium-plugins", bundle, "agents"), agentsDir, log);
+        registered.push(bundle);
+    }
+    return { bundles: registered };
+}
 export function replaceSpecialistSymlink(linkPath, targetAbs) {
     let lstat = null;
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/create-maxy-code",
-  "version": "0.1.114",
+  "version": "0.1.116",
   "description": "Install Maxy — AI for Productive People",
   "bin": {
     "create-maxy-code": "./dist/index.js"

package/payload/platform/config/brand.json

@@ -50,7 +50,7 @@
   "plugins": {
     "core": ["admin", "memory", "docs", "cloudflare", "anthropic", "workflows", "work", "scheduling", "email", "contacts", "projects"],
     "defaultEnabled": ["business-assistant", "sales"],
-    "available": ["telegram", "waitlist", "deep-research", "whatsapp", "replicate", "linkedin-import"],
+    "available": ["telegram", "deep-research", "whatsapp", "replicate", "linkedin-import"],
     "excluded": []
   },
 

package/payload/platform/neo4j/schema.cypher

@@ -7,7 +7,7 @@
 // Constraints
 // ----------------------------------------------------------
 
-// Person.email must be unique (waitlist signups, future users)
+// Person.email must be unique across all Person nodes.
 // Allows multiple nulls — phone-only contacts are not affected.
 CREATE CONSTRAINT person_email_unique IF NOT EXISTS
 FOR (p:Person) REQUIRE p.email IS UNIQUE;

package/payload/platform/plugins/.claude-plugin/marketplace.json

@@ -89,11 +89,6 @@
       "source": "./venture-studio",
       "version": "0.1.0"
     },
-    {
-      "name": "waitlist",
-      "source": "./waitlist",
-      "version": "0.1.0"
-    },
     {
       "name": "whatsapp",
       "source": "./whatsapp",

package/payload/platform/plugins/admin/PLUGIN.md

@@ -136,6 +136,7 @@ Tools are available via the `admin` MCP server.
 - `hooks/webfetch-preflight.mjs` — short-circuits WebFetch on JS-SPA shells with a structured `WEBFETCH_CANNOT_READ_JS_SPA` error so the agent surfaces a loud failure to the owner instead of paying the 60s extraction timeout. Fail-open on any internal error.
 - `hooks/askuserquestion-investigate-gate.sh` — PreToolUse matcher=`AskUserQuestion`. Blocks the question (exit 2) when no read-only investigation tool has fired since the latest real user turn in the session JSONL. The structural fix for the failure class where the agent fabricates a menu before evidence-gathering (session `c085ec2c-46fb-4b73-8865-68cf85866ea8` 2026-05-22 — "change remote access password" → invented options "Admin PIN / Cloudflare tunnel / WiFi password" with zero prior tool_use; post-correction the agent immediately fired `remote-auth-status` → `ToolSearch` → `remote-auth-set-password`, proving it knew the moves). **Allowlist** (exact, with trailing `__<tool>` suffix-match for namespaced `mcp__plugin_<plugin>_<server>__<tool>` aliases): `ToolSearch`, `Grep`, `Glob`, `Read`, `LS`, `NotebookRead`, `Bash`, `WebFetch`, `WebSearch`, plus the read-only admin / memory MCP tools (`*-status`, `*-list`, `*-read`, `skill-find`, `memory-find-candidates`, `profile-read`, `conversation-list`, `memory-list-attachments`, `memory-read-attachment`). **Block message:** `Blocked: AskUserQuestion requires at least one investigation tool (ToolSearch, Grep, Read, *-list, *-status, *-read, skill-find, ...) earlier in this turn. Search the operator's literal phrase first.` **Log line** (stderr, one per call): `[ask-gate] decision=<allow|block> sessionId=<id8> seen=<csv|-> reason=<allowlist-hit|no-investigation|fail-open-no-transcript|fail-open-parse-error>`. **Fail-open** on missing transcript or parse error — nudges, never bricks the UI.
 - `hooks/session-end-retrospective.sh` — **Stop hook.** Fires on every assistant end_turn but exits 0 with `trigger-skipped reason=<role-not-admin|is-specialist|empty-stdin|missing-transcript|no-intent-match>` on every path EXCEPT when the operator's latest real-user message carries an end-intent token (`/end`, `/archive`, `end session`, `archive this session`, case-insensitive, must match the whole message or a standalone line — not embedded in prose). On that path the hook blocks (exit 2 + structured retrospective instruction on stderr per Stop-hook contract) and emits `[session-retrospective] gate-blocked sessionId=<id> reason=sentinel-absent` until the admin agent calls the `session-retrospective-mark-complete` MCP sentinel tool. Completion is recognised by greping the operator's own JSONL (`transcript_path` on the Stop envelope) for a `tool_use` block whose `name` equals that exact string — never by parsing prose ([[feedback_no_stdout_parsing_for_control_flow]], [[feedback_doctrine_paragraph_is_not_a_gate]]). The sentinel-grep doubles as the re-entry guard: every Stop after the sentinel call sees it and exits 0 with `gate-released sessionId=<id>`. Recursion guard: any session whose `MAXY_SPECIALIST` env is set (specialist subagent dispatched via Task tool) skips the gate. The Sidebar archive button POSTs `/:sessionId/archive` directly to the manager which kills the PTY — no Stop fires after that, so clicking archive is the operator's current escape hatch (opt-out remains deferred per the task spec). All emits go through `POST /api/admin/log-ingest`; the only stderr writer is the gate-blocked path (the instruction block the agent reads). The retrospective itself runs as one or more additional turns inside the operator's existing admin session — Task-tool delegation to `database-operator` is the existing IDENTITY.md "Recording" route, not a parallel admin session ([[feedback_deterministic_means_remove_llm]]).
+- `hooks/signal-detector-stop.sh` — **Stop hook.** Task 303 — gbrain port. Fires on every admin-agent end_turn alongside `session-end-retrospective.sh` (both registered on the Stop matcher). Inspects the operator's JSONL transcript and decides whether to dispatch the `signal-detector` specialist for background brain-compounding. Throttle gates: ≥3 new real-user turns since the most recent in-transcript Task call with `subagent_type=signal-detector` (overridable via `MAXY_SIGNAL_DETECTOR_MIN_NEW_TURNS`) AND ≥30 000 ms since the latest real-user message's `timestamp` (overridable via `MAXY_SIGNAL_DETECTOR_MIN_IDLE_MS`). Below either threshold → exit 0 with `trigger-skipped reason=below-{turn,idle}-threshold`. Recursion guard mirrors `session-end-retrospective.sh`: any session with `MAXY_SPECIALIST` set on the PTY env is skipped, plus the in-transcript Task-call grep means the very next Stop after the agent's dispatch turn sees the call and exits 0 (`reason=already-dispatched`). Gate-blocked path emits exit 2 + stderr directive `[system: signal-detector-stop-hook]` per Stop-hook contract; the admin IDENTITY.md "Stop-hook system directives" section binds the agent's response shape (perform one `Task` dispatch, emit a single-space ack, stop). First-fire bootstrap: idempotently copies the template from `$MAXY_PLATFORM_ROOT/templates/specialists/agents/signal-detector.md` into `$ACCOUNT_DIR/specialists/agents/` and appends the AGENTS.md routing line so the specialist is available platform-core without onboarding-flow surgery. All emits go through `POST /api/admin/log-ingest` under tag `signal-detector-hook`. Operator-channel doctrine: by design, only the admin agent's stop fires this hook (public/visitor channels never do — high-value signal flows through the operator, not the visitor).
 - `hooks/turn-completed-graph-write.sh` — **Dormant since Task 214** — the Stop-hook registration is no longer written to account settings.json; admin delegates graph writes to `database-operator` via the Task tool. The script, envelope walker, loopback `/api/admin/claude-sessions` 127.0.0.1 bypass, `[turn-recorder]` emitters, recorder-auto-archive subscriber, and `initialMessage` envelope spec are preserved as reusable infrastructure for any future autonomous post-turn flow. Historical contract (still describes the dormant path): Stop hook fired once per completed admin-agent turn. Gates on `MAXY_SESSION_ROLE=admin` + `MAXY_SPECIALIST!=database-operator` so it never recurses into the recorder PTY or fires on public sessions. **Task 147** — the recorder is spawned via the same route Sidebar uses. ONE POST to `POST /api/admin/claude-sessions`, body carries `{specialist:'database-operator', model:'haiku', initialMessage:<json-envelope>, adminSessionId:<op>}` — no synthetic `senderId: 'turn-recorder'` marker. The Hono wrapper bypasses cookie auth on this exact method+path when the request originates from `127.0.0.1` (same trust boundary the claude-session-manager itself relies on), looks up the operator's senderId from the manager's `/<adminSessionId>/meta`, and forwards a Sidebar-shape spawn body. The `/recorder-spawn` sibling route is gone. The hook reads its UI port from `MAXY_UI_INTERNAL_PORT` (stamped on the manager systemd unit) — no fallback; absence emits `[turn-recorder] spawn-failed reason=missing-env env=MAXY_UI_INTERNAL_PORT` to stderr instead of silently 19199-ing. **Task 177** — `initialMessage` is a JSON-stringified envelope; the schema lives in [`platform/plugins/docs/references/admin-session.md`](../docs/references/admin-session.md) under "`initialMessage` JSON envelope (Task 177)". Top-level keys exactly: `turns`, `conversationId`, `accountId`, `occurredAt`. `turns` is the full conversation transcript, oldest first, newest last, with each entry `{ role: "user"|"assistant", text, ts, toolCalls? }`. No windowing, no truncation. Multi-record assistant messages collapse on `message.id`. `tool_use` and matching `tool_result` blocks attach as a single `toolCalls` entry on the owning assistant turn; the user record carrying only the `tool_result` does not create a separate user turn. No leading instruction prose. `toolCalls[].input` and `toolCalls[].output` are native JSON values, never re-stringified. (Replaces Task 175's `(operatorMessage, assistantReply)` pair, which asserted a temporal Q→A relationship the walker never enforced.) One observability line `[turn-recorder] envelope sessionId=<op> turnsCount=<n> userTurns=<n> assistantTurns=<n> toolCallTurns=<n>` precedes `spawn-request`. The envelope rides on the `/spawn` body as a trailing positional argv to `claude`, so the database-operator session's JSONL first `role=user` line is the JSON object verbatim. No separate `POST /:id/input` call, no bracketed-paste, no keystroke injection. The recorder-auto-archive subscriber stops the recorder PTY as soon as its JSONL contains an assistant message with `stop_reason === "end_turn"`. **Task 129** — every emit goes through `POST /api/admin/log-ingest` so the lines land in `server.log` keyed by the operator session id. The chain is `trigger` → `spawn-request` → `spawn-success` → `input-delivered` → `tool-call` × N → `tool-result` × N → `write-complete` → `auto-archive`; each gated-off path emits one `trigger-skipped reason=<role-not-admin|is-recorder|empty-stdin|missing-transcript|conversation-empty>` line. Failure modes — `spawn-failed`, `tool-surface-missing`, `input-failed`, `write-empty`, `auto-archive reason=stale-recorder` — each emit one named line; absence is itself a defect.
 
 ## Session identifiers (Task 135)

package/payload/platform/plugins/admin/hooks/signal-detector-stop.sh

@@ -0,0 +1,309 @@
+#!/usr/bin/env bash
+# Stop hook — gbrain signal-detector dispatch. Task 303.
+#
+# Fires on every admin-agent assistant end_turn. Inspects the operator's
+# JSONL transcript and decides whether to invoke the `signal-detector`
+# specialist to extract entity mentions and original-thinking candidates
+# from the conversation slice since the last dispatch.
+#
+# Trigger logic (must clear both gates to fire):
+#   - >= MIN_NEW_TURNS new real-user messages since the most recent
+#     in-transcript Task dispatch with subagent_type='signal-detector'
+#     (default 3 — overridable via MAXY_SIGNAL_DETECTOR_MIN_NEW_TURNS).
+#   - >= MIN_IDLE_MS milliseconds since the latest real-user message's
+#     `timestamp` (default 30_000 — overridable via
+#     MAXY_SIGNAL_DETECTOR_MIN_IDLE_MS). Captures "operator paused, not
+#     mid-thought".
+#
+# Recursion guard. The dispatch resolves through a Task tool call carrying
+# `subagent_type=signal-detector`; once such a call appears in the transcript
+# after the latest real-user message, the gate has already fired for this
+# turn and must NOT re-fire. Same shape as
+# session-end-retrospective.sh's sentinel grep
+# ([[feedback_no_stdout_parsing_for_control_flow]] /
+# [[feedback_doctrine_paragraph_is_not_a_gate]]) — control flow gates on a
+# structural tool_use, never on prose.
+#
+# Specialist auto-install on first fire. The template ships at
+# `$MAXY_TEMPLATES_DIR/specialists/agents/signal-detector.md` (or
+# `$ACCOUNT_DIR/../templates/...` via PLATFORM_ROOT). On the first fire
+# that decides to dispatch, the hook idempotently copies the template into
+# `$ACCOUNT_DIR/specialists/agents/` and appends the AGENTS.md routing line
+# if absent — so signal-detector is platform-core (no operator install
+# step) without surgery on the onboarding flow.
+#
+# Gating (emits via `/api/admin/log-ingest`; stderr stays silent on every
+# skip path; the gate-blocked path is the only stderr emitter, by Stop-hook
+# contract — exit 2 + stderr is how the agent receives the dispatch
+# directive):
+#   - MAXY_SESSION_ROLE must equal "admin"            → reason=role-not-admin
+#   - MAXY_SPECIALIST must be empty                   → reason=is-specialist
+#   - Stop-hook stdin must be non-empty               → reason=empty-stdin
+#   - transcript_path must exist on disk              → reason=missing-transcript
+#   - new real-user turns since last fire < MIN_NEW   → reason=below-turn-threshold
+#   - idle_ms < MIN_IDLE_MS                           → reason=below-idle-threshold
+#   - latest real-user message older than the latest  → reason=already-dispatched
+#     signal-detector dispatch
+#
+# Blocks:
+#   - gate-blocked sessionId=<id> reason=dispatching newTurns=<n> idleMs=<n>
+#
+# Input: Claude Code's Stop hook stdin shape
+#   { "session_id": "<intrinsic>", "transcript_path": "<jsonl path>", ... }
+
+set -uo pipefail
+
+MIN_NEW_TURNS="${MAXY_SIGNAL_DETECTOR_MIN_NEW_TURNS:-3}"
+MIN_IDLE_MS="${MAXY_SIGNAL_DETECTOR_MIN_IDLE_MS:-30000}"
+
+UI_PORT="${MAXY_UI_INTERNAL_PORT:-}"
+if [ -z "$UI_PORT" ]; then
+  echo "[signal-detector-hook] 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"
+
+emit_log() {
+  local line="$1"
+  curl -sS -o /dev/null -X POST \
+    -H 'Content-Type: application/json' \
+    --max-time 2 \
+    --data "$(python3 -c '
+import sys, json
+print(json.dumps({"tag": "signal-detector-hook", "level": "info", "line": sys.argv[1]}))
+' "$line")" \
+    "$LOG_INGEST_URL" 2>/dev/null || true
+}
+
+INPUT=""
+if [ -t 0 ]; then
+  INPUT=""
+else
+  INPUT=$(cat)
+fi
+
+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 ""
+    print(f"{sid}\t{tpath}")
+except Exception:
+    print("\t")
+' 2>/dev/null)
+SESSION_ID="${PARSED%%	*}"
+TRANSCRIPT_PATH="${PARSED#*	}"
+SESSION_ID_REPORTED="${SESSION_ID:-unknown}"
+
+if [ "${MAXY_SESSION_ROLE:-}" != "admin" ]; then
+  emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=role-not-admin"
+  exit 0
+fi
+# Recursion guard. A specialist subagent (database-operator, signal-detector
+# itself, etc.) stamps `MAXY_SPECIALIST` on its PTY env. Skip — the hook
+# only fires on the operator's own admin session, never on a subagent's
+# own stop.
+if [ -n "${MAXY_SPECIALIST:-}" ]; then
+  emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=is-specialist specialist=${MAXY_SPECIALIST}"
+  exit 0
+fi
+if [ -z "$INPUT" ]; then
+  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
+  emit_log "trigger-skipped sessionId=${SESSION_ID_REPORTED} reason=missing-transcript"
+  exit 0
+fi
+
+# Single Python pass over the transcript. Returns three tab-separated
+# fields:
+#   1. count of real-user messages whose timestamp is more recent than the
+#      latest in-transcript Task dispatch with subagent_type=signal-detector
+#      (or, when no such dispatch exists yet, the total real-user count)
+#   2. idle_ms — milliseconds between the latest real-user message's
+#      timestamp and now (hook fire time)
+#   3. excerpt — the latest real-user message's text, truncated to 2000
+#      chars and base64-encoded so newlines and quotes survive the shell
+#      round-trip
+INSPECTION=$(TRANSCRIPT_PATH="$TRANSCRIPT_PATH" python3 - <<'PY'
+import os, json, base64
+from datetime import datetime, timezone
+
+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 extract_user_text(rec):
+    msg = rec.get("message", {}) or {}
+    content = msg.get("content")
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        out = []
+        for b in content:
+            if isinstance(b, dict) and b.get("type") == "text":
+                t = b.get("text")
+                if isinstance(t, str):
+                    out.append(t)
+        return "".join(out)
+    return ""
+
+def latest_signal_detector_dispatch_index(records):
+    """Return the index of the most recent assistant tool_use of `Task`
+    whose `subagent_type` is `signal-detector`, or -1 if none."""
+    for i in range(len(records) - 1, -1, -1):
+        rec = records[i]
+        if not isinstance(rec, dict) or rec.get("type") != "assistant":
+            continue
+        msg = rec.get("message", {}) or {}
+        if msg.get("role") != "assistant":
+            continue
+        content = msg.get("content")
+        if not isinstance(content, list):
+            continue
+        for b in content:
+            if not isinstance(b, dict) or b.get("type") != "tool_use":
+                continue
+            if b.get("name") != "Task":
+                continue
+            inp = b.get("input", {})
+            if isinstance(inp, dict) and inp.get("subagent_type") == "signal-detector":
+                return i
+    return -1
+
+path = os.environ["TRANSCRIPT_PATH"]
+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:
+    # Fail-open — print empty fields, the bash side will treat as missing.
+    print("0\t0\t")
+    raise SystemExit(0)
+
+last_dispatch_idx = latest_signal_detector_dispatch_index(records)
+
+# Count real-user messages after last_dispatch_idx (exclusive); when
+# last_dispatch_idx is -1, count from the start.
+new_user_count = 0
+latest_user_ts = None
+latest_user_text = ""
+start = last_dispatch_idx + 1
+for i in range(start, len(records)):
+    rec = records[i]
+    if is_real_user(rec):
+        new_user_count += 1
+        ts = rec.get("timestamp") or ""
+        if isinstance(ts, str) and ts:
+            latest_user_ts = ts
+            latest_user_text = extract_user_text(rec).strip()
+
+if latest_user_ts is None:
+    print(f"{new_user_count}\t0\t")
+    raise SystemExit(0)
+
+try:
+    # JSONL timestamps from Claude Code are ISO 8601 with Z suffix.
+    parsed = datetime.fromisoformat(latest_user_ts.replace("Z", "+00:00"))
+    now = datetime.now(timezone.utc)
+    idle_ms = max(0, int((now - parsed).total_seconds() * 1000))
+except Exception:
+    idle_ms = 0
+
+excerpt = latest_user_text[:2000]
+b64 = base64.b64encode(excerpt.encode("utf-8")).decode("ascii")
+print(f"{new_user_count}\t{idle_ms}\t{b64}")
+PY
+)
+NEW_TURNS="${INSPECTION%%	*}"
+REMAINING="${INSPECTION#*	}"
+IDLE_MS="${REMAINING%%	*}"
+EXCERPT_B64="${REMAINING#*	}"
+
+# Throttle gates.
+if [ "$NEW_TURNS" -eq 0 ] 2>/dev/null; then
+  emit_log "trigger-skipped sessionId=${SESSION_ID} reason=already-dispatched newTurns=0"
+  exit 0
+fi
+if [ "$NEW_TURNS" -lt "$MIN_NEW_TURNS" ] 2>/dev/null; then
+  emit_log "trigger-skipped sessionId=${SESSION_ID} reason=below-turn-threshold newTurns=${NEW_TURNS} threshold=${MIN_NEW_TURNS}"
+  exit 0
+fi
+if [ "$IDLE_MS" -lt "$MIN_IDLE_MS" ] 2>/dev/null; then
+  emit_log "trigger-skipped sessionId=${SESSION_ID} reason=below-idle-threshold idleMs=${IDLE_MS} threshold=${MIN_IDLE_MS}"
+  exit 0
+fi
+
+# Specialist auto-install. The template lives under
+# `$PLATFORM_ROOT/templates/specialists/agents/signal-detector.md`. The
+# installer / seeder copies templates to per-account dirs at onboarding;
+# this fallback heals an account that pre-dates the template's existence
+# without forcing the operator to re-run onboarding.
+PLATFORM_ROOT_FALLBACK="${MAXY_PLATFORM_ROOT:-}"
+ACCOUNT_DIR_LOCAL="${ACCOUNT_DIR:-}"
+SPECIALIST_TARGET="${ACCOUNT_DIR_LOCAL}/specialists/agents/signal-detector.md"
+if [ -n "$ACCOUNT_DIR_LOCAL" ] && [ ! -f "$SPECIALIST_TARGET" ] && [ -n "$PLATFORM_ROOT_FALLBACK" ]; then
+  TEMPLATE_SRC="${PLATFORM_ROOT_FALLBACK}/templates/specialists/agents/signal-detector.md"
+  if [ -f "$TEMPLATE_SRC" ]; then
+    mkdir -p "$(dirname "$SPECIALIST_TARGET")" 2>/dev/null
+    cp "$TEMPLATE_SRC" "$SPECIALIST_TARGET" 2>/dev/null
+    AGENTS_MD="${ACCOUNT_DIR_LOCAL}/agents/admin/AGENTS.md"
+    if [ -f "$AGENTS_MD" ]; then
+      if ! grep -q "specialists:signal-detector" "$AGENTS_MD" 2>/dev/null; then
+        printf '%s\n' "- **specialists:signal-detector**: Background brain-compounder dispatched only by the admin-agent Stop hook (\`platform/plugins/admin/hooks/signal-detector-stop.sh\`). Never invoke manually." >> "$AGENTS_MD"
+      fi
+    fi
+    emit_log "bootstrap-installed sessionId=${SESSION_ID} target=${SPECIALIST_TARGET}"
+  fi
+fi
+
+EXCERPT_PREVIEW=$(printf '%s' "$EXCERPT_B64" | base64 --decode 2>/dev/null | head -c 200 | tr '\n' ' ')
+emit_log "gate-blocked sessionId=${SESSION_ID} reason=dispatching newTurns=${NEW_TURNS} idleMs=${IDLE_MS} preview=$(printf '%s' "$EXCERPT_PREVIEW" | sed 's/[\"]//g' | head -c 80)"
+
+# Emit the dispatch directive on stderr per Stop-hook contract. The admin
+# IDENTITY.md "Stop-hook system directives" section names this token prefix
+# and the binding response shape — agent must perform the single Agent
+# dispatch and emit an empty acknowledgement on return, nothing else.
+EXCERPT_DECODED=$(printf '%s' "$EXCERPT_B64" | base64 --decode 2>/dev/null)
+
+cat >&2 <<DIRECTIVE
+[system: signal-detector-stop-hook]
+Dispatch the signal-detector specialist NOW using the Task tool. Do not respond to the operator; this is a background brain-compounding task and the operator does not see this turn. After the specialist returns its one-line summary, emit a single space character and stop.
+
+Agent dispatch parameters:
+  subagent_type: signal-detector
+  prompt: |
+    accountId: ${ACCOUNT_ID:-<unset>}
+    sessionId: ${SESSION_ID}
+    newUserTurnsSinceLastRun: ${NEW_TURNS}
+    idleMsBeforeFire: ${IDLE_MS}
+
+    The operator's latest turn (truncated to 2000 chars):
+    ${EXCERPT_DECODED}
+
+    Resolve the operator's most recent :Message in this conversation via memory-search (filter by conversationId from your MCP server env), then write :MENTIONS edges and :Idea nodes per your specialist body. Return one line in the documented output shape.
+DIRECTIVE
+
+exit 2

package/payload/platform/plugins/contacts/mcp/dist/index.js

@@ -49,7 +49,7 @@ eagerTool(server, "contact-create", "Create a new contact (schema:Person) in the
     status: z
         .string()
         .optional()
-        .describe("Contact status (e.g. active, prospect, waitlist)"),
+        .describe("Contact status (e.g. active, prospect, booked, archived)"),
     relationships: z
         .array(z.object({
         type: z.string().describe("Relationship type (e.g. PARTICIPATES_IN, WORKS_FOR, KNOWN_VIA)"),
@@ -85,7 +85,7 @@ eagerTool(server, "contact-create", "Create a new contact (schema:Person) in the
             content: [
                 {
                     type: "text",
-                    text: `Contact created: ${result.identifier} (ID: ${result.nodeId}, status: ${params.status ?? "waitlist"})`,
+                    text: `Contact created: ${result.identifier} (ID: ${result.nodeId}, status: ${params.status ?? "prospect"})`,
                 },
             ],
         };
@@ -188,7 +188,7 @@ eagerTool(server, "contact-list", "List contacts with optional filters. Returns
     status: z
         .string()
         .optional()
-        .describe("Filter by status (e.g. waitlist)"),
+        .describe("Filter by status (e.g. prospect)"),
     source: z
         .string()
         .optional()