@rubytech/create-maxy-code 0.1.565 → 0.1.567

package/package.json

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

package/payload/platform/config/brand-registry.json

@@ -6,7 +6,7 @@
       "vncDisplay": 99,
       "rfbPort": 5900,
       "websockifyPort": 6080,
-      "cdpPort": 9222
+      "cdpPort": 9322
     },
     {
       "hostname": "property-administrators",

package/payload/platform/config/brand.json

@@ -12,7 +12,7 @@
   "vncDisplay": 99,
   "rfbPort": 5900,
   "websockifyPort": 6080,
-  "cdpPort": 9222,
+  "cdpPort": 9322,
   "claudeSessionManagerPort": 19400,
   "outlookClientId": "",
   "googleClientId": "",

package/payload/platform/neo4j/schema.cypher

@@ -2381,3 +2381,12 @@ FOR (n:StockMovement) ON (n.accountId);
 
 CREATE INDEX store_location_account IF NOT EXISTS
 FOR (n:StoreLocation) ON (n.accountId);
+
+CREATE INDEX stock_position_account IF NOT EXISTS
+FOR (n:StockPosition) ON (n.accountId);
+
+CREATE INDEX demand_observation_account IF NOT EXISTS
+FOR (n:DemandObservation) ON (n.accountId);
+
+CREATE INDEX replenishment_policy_account IF NOT EXISTS
+FOR (n:ReplenishmentPolicy) ON (n.accountId);

package/payload/platform/package-lock.json

@@ -9,7 +9,11 @@
       "workspaces": [
         "plugins/*/mcp",
         "services/*"
-      ]
+      ],
+      "dependencies": {
+        "neo4j-driver": "^5.28.1",
+        "pdf-lib": "^1.17.1"
+      }
     },
     "node_modules/@babel/runtime": {
       "version": "7.29.2",
@@ -585,6 +589,10 @@
       "resolved": "plugins/graph-viewer/mcp",
       "link": true
     },
+    "node_modules/@maxy/inventory": {
+      "resolved": "plugins/inventory/mcp",
+      "link": true
+    },
     "node_modules/@maxy/joblogic": {
       "resolved": "plugins/joblogic/mcp",
       "link": true
@@ -998,6 +1006,24 @@
         "url": "https://github.com/sponsors/Boshen"
       }
     },
+    "node_modules/@pdf-lib/standard-fonts": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/standard-fonts/-/standard-fonts-1.0.0.tgz",
+      "integrity": "sha512-hU30BK9IUN/su0Mn9VdlVKsWBS6GyhVfqjwl1FjZN4TxP6cCw0jP2w7V3Hf5uX7M0AZJ16vey9yE0ny7Sa59ZA==",
+      "license": "MIT",
+      "dependencies": {
+        "pako": "^1.0.6"
+      }
+    },
+    "node_modules/@pdf-lib/upng": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@pdf-lib/upng/-/upng-1.0.1.tgz",
+      "integrity": "sha512-dQK2FUMQtowVP00mtIksrlZhdFXQZPC+taih1q4CvPZ5vqdxR/LKBaFg0oAfzd1GlHZXXSPdQfzQnt+ViGvEIQ==",
+      "license": "MIT",
+      "dependencies": {
+        "pako": "^1.0.10"
+      }
+    },
     "node_modules/@pinojs/redact": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/@pinojs/redact/-/redact-0.4.0.tgz",
@@ -3790,6 +3816,12 @@
         "node": ">=6"
       }
     },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
     "node_modules/parseley": {
       "version": "0.13.1",
       "resolved": "https://registry.npmjs.org/parseley/-/parseley-0.13.1.tgz",
@@ -3857,6 +3889,24 @@
         "node": ">= 14.16"
       }
     },
+    "node_modules/pdf-lib": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/pdf-lib/-/pdf-lib-1.17.1.tgz",
+      "integrity": "sha512-V/mpyJAoTsN4cnP31vc0wfNA1+p20evqqnap0KLoRUN0Yk/p3wN52DOEsL4oBFcLdb76hlpKPtzJIgo67j/XLw==",
+      "license": "MIT",
+      "dependencies": {
+        "@pdf-lib/standard-fonts": "^1.0.0",
+        "@pdf-lib/upng": "^1.0.1",
+        "pako": "^1.0.11",
+        "tslib": "^1.11.1"
+      }
+    },
+    "node_modules/pdf-lib/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
     "node_modules/peberminta": {
       "version": "0.10.0",
       "resolved": "https://registry.npmjs.org/peberminta/-/peberminta-0.10.0.tgz",
@@ -6644,6 +6694,19 @@
         "vitest": "^4.1.2"
       }
     },
+    "plugins/inventory/mcp": {
+      "name": "@maxy/inventory",
+      "version": "0.1.0",
+      "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.12.1",
+        "neo4j-driver": "^5.28.1"
+      },
+      "devDependencies": {
+        "@types/node": "^22.0.0",
+        "typescript": "^5.7.0",
+        "vitest": "^4.1.2"
+      }
+    },
     "plugins/joblogic/mcp": {
       "name": "@maxy/joblogic",
       "version": "0.1.0",
@@ -6688,6 +6751,7 @@
       "dependencies": {
         "@microsoft/microsoft-graph-client": "^3.0.7",
         "@modelcontextprotocol/sdk": "^1.12.1",
+        "neo4j-driver": "^5.28.1",
         "zod": "^3.24.0"
       },
       "devDependencies": {
@@ -6727,6 +6791,7 @@
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.12.1",
         "cron-parser": "^4.9.0",
+        "imapflow": "^1.0.171",
         "neo4j-driver": "^5.28.1",
         "zod": "^3.24.0"
       },

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

@@ -74,6 +74,11 @@
       "source": "./graph-viewer",
       "version": "0.1.0"
     },
+    {
+      "name": "inventory",
+      "source": "./inventory",
+      "version": "0.1.0"
+    },
     {
       "name": "ledger",
       "source": "./ledger",

package/payload/platform/plugins/admin/hooks/lib/maxy-mcp-plugins.txt

@@ -8,6 +8,7 @@ filesystem
 google
 graph
 graph-viewer
+inventory
 joblogic
 ledger
 memory

package/payload/platform/plugins/admin/skills/platform-architecture/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: platform-architecture
 description: Use when grounding any documented-surface claim about what Maxy ships — plugins, skills, specialists, install/deploy flows, internals. This is the install catalogue, not evidence of what is enabled on the current account. For install state on this account, call `capabilities-here`; for documented surface, cite the `Source:` URL inline.
-content-hash: sha256:c0d108d50a5c5109da65ad22f4838284c614aed9161d4b5ab70c6db7c30904c2
+content-hash: sha256:a5382f5dffc8946000b831c6433f7312cae263450bd9e97bfacb58017ae7b783
 brand: maxy-code
 product-name: Maxy
 ---
@@ -1773,6 +1773,53 @@ The first-run dialog is answered for the session, and the watcher that guards ag
 
 Two standing audits reconcile that chain rather than waiting for someone to notice. `op=public-notify-reconcile` reports `routed` against `answered`, so a visitor routed to an agent that never replied shows as `answerGap`. `op=spawn-census` reports attempts against successes. A non-zero gap, or attempts with no successes, is a fault even when nothing has been reported.
 
+## Delivery parity, and where its lines actually land
+
+**The contract.** For any channel session, the set of answers delivered to the
+chat equals the transcript's assistant `text` blocks **for turns that answered a
+channel inbound**. An answer readable in the reader and absent from the chat is a
+defect. Turns that answered no inbound — subagent side-chains, turns driven from
+claude.ai — are deliberately outside that set: the credit guards are what keep
+them out of a customer's chat.
+
+Each door's `src/parity.test.ts` asserts the contract end to end against a real
+JSONL and the real follower.
+
+**Six discard sites, each now logged.** A follower outcome is dropped at:
+
+| File | Guard | `reason=` |
+|---|---|---|
+| `telegram-channel/src/server.ts:241` | `pendingTurns <= 0` | `no-credit` |
+| `webchat-channel/src/server.ts:378` | `pendingTurns <= 0` | `no-credit` |
+| `whatsapp-channel/src/server.ts:481` | `pendingTurns <= 0` | `no-credit` |
+| `whatsapp-channel/src/server.ts:489` | `consumedInbounds <= 0` | `no-consumed-inbound` |
+| `whatsapp-channel/src/server.ts:617` | `pendingTurns <= 0` (2nd follower) | `no-credit` |
+| `whatsapp-channel/src/server.ts:620` | `consumedInbounds <= 0` (2nd follower) | `no-consumed-inbound` |
+
+```
+[<door>-channel]     op=turn-drop sessionId=… messageId=… finalBytes=… reason=…
+[<door>-turn-census] op=census sessionId=… pending=… held=<0|1> heldMessageId=… heldAgeMs=… lastMessageId=…
+```
+
+Any `op=turn-drop` with `finalBytes>0` is a lost answer. The census runs every
+60 s per follower; `held=1` with `heldAgeMs` rising across ticks is a hold that
+never resolved, and `pending` not returning to 0 with no inbound in flight is
+credit drift.
+
+**Read them in the right file.** Both lines are emitted by the *channel MCP
+server*, whose stderr is teed to `${LOG_DIR}/mcp-<serverName>-<sessionId>.log`
+(`claude-session-manager/src/channel-spawn-tee.ts`). They are **never** in
+`server.log`, which carries the gateway-side half only — `op=turn-end`,
+`op=turn-answer-absent`, `delivered=`. Grepping `server.log` for a drop returns
+nothing and means nothing.
+
+```bash
+# the discard and the hold, per session
+grep -E 'op=(turn-drop|census)' ~/.<brand>/logs/mcp-telegram-channel-*.log | tail -20
+# the gateway's view of the same turn
+grep -E 'op=(turn-end|turn-answer-absent)' ~/.<brand>/logs/server.log | grep <sessionId>
+```
+
 ---
 # Settings
 Source: https://docs.getmaxy.com/settings.md

package/payload/platform/plugins/admin/skills/public-agent-manager/SKILL.md

@@ -47,6 +47,10 @@ Each agent lives at `{accountDir}/agents/{slug}/`:
 }
 ```
 
+### model
+
+`model` is live. A public spawn reads it from this file and passes it to the agent's process as `--model`; changing it here changes the next spawn's model with no code change and no restart. An id outside the three listed below is ignored, and the spawn falls back to the account's `publicModel`.
+
 ### Toolless by construction
 
 The public agent has no tools. It cannot search the graph, read files, run commands, or load skills mid-conversation. Everything it knows is the KNOWLEDGE.md and SOUL assembled into its system prompt at spawn time. There is no operator toggle for this — it is the fixed posture for every public agent on every channel. If the agent needs to surface graph content created after deployment, refresh its KNOWLEDGE.md (see Update knowledge below); the agent itself never reaches the live graph.
@@ -83,7 +87,7 @@ Tagging routes a node to the suggestion surface; it does not publish it. A tagge
 
 ### Model Options
 
-Present as a `select` field within the agent configuration `form` during creation:
+Present as a `select` field within the agent configuration `form` during creation. The chosen id is written to `config.json` `model` and is what the agent's spawns actually run on:
 
 | Model | ID | Suitability | Cost |
 |-------|-----|------------|------|

package/payload/platform/plugins/admin/skills/whats-new/SKILL.md

@@ -9,6 +9,16 @@ Invoked by the admin agent directly.
 
 This is the platform's release timeline, newest first. Each entry shows the date it shipped and the version it shipped in, so you can tell the operator how current their install is. To compare, read the installed version from `capabilities-here` and match it against the versions below. Keep answers high level and in plain English; this is a summary, not a full commit log.
 
+## 2026-08-05 (0.1.567)
+
+- An answer you can see in the reader is now delivered to the channel it belongs to. A turn that ended on a thinking block was closing before its answer row arrived, and that answer was dropped. Every channel now holds a close that carries no message, merges a split answer back into one message, and records a line at each of the six points where a turn used to be discarded silently.
+- A public agent now runs on the model it is configured with. Public conversations were ignoring the agent's own setting and inheriting the admin model instead.
+- Retail installs can plan, not just record. A new inventory area adds stock positions, demand history, supplier terms and replenishment policy, and answers what to order and when, rather than only recording what has already been sold.
+
+## 2026-08-05 (0.1.566)
+
+- Installing or upgrading Maxy on a machine that also runs another Maxy-family product no longer fails because a browser is in the way. Maxy's browser-automation port was the one every browser tool picks by default when nothing tells it otherwise, so an assistant on the other product could take it and the install would stop rather than write over a port in use. Maxy now uses a port outside that range.
+
 ## 2026-08-05 (0.1.565)
 
 - Every channel now delivers the assistant's answer the same way the admin webchat does: the answer is taken from the conversation record and sent. Previously WhatsApp, Telegram and the public webchat asked the assistant to call a send tool, so an answer was suppressed when it called and lost entirely when it did not. Long answers arrive as ordered segments, and an answer meant for you fans out to every channel you have live, naming any that could not be reached.

package/payload/platform/plugins/docs/references/channel-wake-and-prompt.md

@@ -86,3 +86,50 @@ op=startup-watch                  state=disposed
 The first-run dialog is answered for the session, and the watcher that guards against an *unanswered* one drops what it saw before that answer. `bufferCleared=false` means the confirm fired and the drop did not, which is the shape that killed a resumed spawn on 2026-08-01: the answered dialog's own footer stayed in the buffer, the replayed transcript slid past it, and the spawn was blocked by a line the agent itself had written the day before.
 
 Two standing audits reconcile that chain rather than waiting for someone to notice. `op=public-notify-reconcile` reports `routed` against `answered`, so a visitor routed to an agent that never replied shows as `answerGap`. `op=spawn-census` reports attempts against successes. A non-zero gap, or attempts with no successes, is a fault even when nothing has been reported.
+
+## Delivery parity, and where its lines actually land
+
+**The contract.** For any channel session, the set of answers delivered to the
+chat equals the transcript's assistant `text` blocks **for turns that answered a
+channel inbound**. An answer readable in the reader and absent from the chat is a
+defect. Turns that answered no inbound — subagent side-chains, turns driven from
+claude.ai — are deliberately outside that set: the credit guards are what keep
+them out of a customer's chat.
+
+Each door's `src/parity.test.ts` asserts the contract end to end against a real
+JSONL and the real follower.
+
+**Six discard sites, each now logged.** A follower outcome is dropped at:
+
+| File | Guard | `reason=` |
+|---|---|---|
+| `telegram-channel/src/server.ts:241` | `pendingTurns <= 0` | `no-credit` |
+| `webchat-channel/src/server.ts:378` | `pendingTurns <= 0` | `no-credit` |
+| `whatsapp-channel/src/server.ts:481` | `pendingTurns <= 0` | `no-credit` |
+| `whatsapp-channel/src/server.ts:489` | `consumedInbounds <= 0` | `no-consumed-inbound` |
+| `whatsapp-channel/src/server.ts:617` | `pendingTurns <= 0` (2nd follower) | `no-credit` |
+| `whatsapp-channel/src/server.ts:620` | `consumedInbounds <= 0` (2nd follower) | `no-consumed-inbound` |
+
+```
+[<door>-channel]     op=turn-drop sessionId=… messageId=… finalBytes=… reason=…
+[<door>-turn-census] op=census sessionId=… pending=… held=<0|1> heldMessageId=… heldAgeMs=… lastMessageId=…
+```
+
+Any `op=turn-drop` with `finalBytes>0` is a lost answer. The census runs every
+60 s per follower; `held=1` with `heldAgeMs` rising across ticks is a hold that
+never resolved, and `pending` not returning to 0 with no inbound in flight is
+credit drift.
+
+**Read them in the right file.** Both lines are emitted by the *channel MCP
+server*, whose stderr is teed to `${LOG_DIR}/mcp-<serverName>-<sessionId>.log`
+(`claude-session-manager/src/channel-spawn-tee.ts`). They are **never** in
+`server.log`, which carries the gateway-side half only — `op=turn-end`,
+`op=turn-answer-absent`, `delivered=`. Grepping `server.log` for a drop returns
+nothing and means nothing.
+
+```bash
+# the discard and the hold, per session
+grep -E 'op=(turn-drop|census)' ~/.<brand>/logs/mcp-telegram-channel-*.log | tail -20
+# the gateway's view of the same turn
+grep -E 'op=(turn-end|turn-answer-absent)' ~/.<brand>/logs/server.log | grep <sessionId>
+```

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

@@ -0,0 +1,21 @@
+{
+  "name": "inventory",
+  "description": "Retail replenishment planning. Records measured stock and observed demand at a product-plus-location grain, holds supplier lead times and service-level policy, and computes what to reorder rather than storing it. Provides inventory-stock-record, inventory-demand-record, inventory-policy-set, inventory-supplier-terms-set, inventory-forecast, inventory-replenish-plan, inventory-purchase-order-record.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Rubytech LLC"
+  },
+  "mcpServers": {
+    "inventory": {
+      "type": "stdio",
+      "command": "node",
+      "args": [
+        "${CLAUDE_PLUGIN_ROOT}/lib/mcp-spawn-tee/index.js",
+        "${CLAUDE_PLUGIN_ROOT}/mcp/dist/index.js"
+      ],
+      "env": {
+        "MCP_SPAWN_TEE_NAME": "inventory"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+---
+name: inventory
+description: "Retail replenishment planning. Records measured stock and observed demand at a product-plus-location grain, holds supplier lead times and service-level policy, and computes what to reorder rather than storing it. Provides inventory-stock-record, inventory-demand-record, inventory-policy-set, inventory-supplier-terms-set, inventory-forecast, inventory-replenish-plan, inventory-purchase-order-record."
+tools:
+  - name: inventory-stock-record
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: write_local
+  - name: inventory-demand-record
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: write_local
+  - name: inventory-policy-set
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: write_local
+  - name: inventory-supplier-terms-set
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: write_local
+  - name: inventory-forecast
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: read
+  - name: inventory-replenish-plan
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: read
+  - name: inventory-purchase-order-record
+    publicAllowlist: false
+    adminAllowlist: true
+    riskClass: write_local
+always: false
+embed: false
+metadata: {"platform":{}}
+mcp:
+  command: node
+  args:
+    - ${PLATFORM_ROOT}/lib/mcp-spawn-tee/dist/index.js
+    - ${PLATFORM_ROOT}/plugins/inventory/mcp/dist/index.js
+  env:
+    MCP_SPAWN_TEE_NAME: inventory
+    LOG_DIR: ${LOG_DIR}
+    PLATFORM_ROOT: ${PLATFORM_ROOT}
+    ACCOUNT_ID: ${ACCOUNT_ID}
+    SESSION_ID: ${SESSION_ID}
+    AGENT_SLUG: ${AGENT_SLUG}
+mcp-manifest: auto
+---
+
+# Inventory
+
+Replenishment planning for a retail account. Admin agent only.
+
+Load `platform/plugins/memory/references/schema-retail.md` before writing: this plugin's nodes are declared there.
+
+## Nothing it recommends is stored
+
+The forecast and the reorder point are computed from recorded facts on every call. There is no `Forecast` node and no stored plan.
+
+A stored recommendation drifts the moment stock moves by a path that forgets to update it, and nothing fails when it does: the plan simply reports a number that no longer reconciles against the positions it was computed from. A computed figure cannot disagree with the data it is computed from.
+
+## The planning grain is a product at a location
+
+Stock lives on `:StockPosition`, keyed on product plus location, not on `Product.stockLevel`. A retailer with a shop and a warehouse can say how much sits where; a single-site seller simply has one location.
+
+No tool here reads `Product.stockLevel`.
+
+## Nothing is defaulted
+
+A line that cannot be computed, because the supplier has no lead time, the product has no policy, or there is no demand history, comes back named as skipped with the missing input. It is never computed from a substituted value: a default service level or a guessed lead time produces a confident, wrong order quantity, which is worse than no answer.
+
+## Data age is returned, not assumed
+
+Stock arrives by upload, so it is stale by construction. `inventory-replenish-plan` returns the oldest and newest `asOf` it actually read. Report that age to the operator as a fact from the tool rather than assuming the data is current.

package/payload/platform/plugins/inventory/lib/mcp-spawn-tee/index.js

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MCP spawn-tee — in-process stderr capture + lifecycle observability.
+ *
+ * Claude Code spawns each MCP server itself; the platform never holds a
+ * ChildProcess handle. This shim sits between Claude Code and the real MCP
+ * server: Claude Code runs `node <this> <real-entry>`, and the shim runs the
+ * real entry IN ITS OWN PROCESS via dynamic import() — one node runtime, not
+ * two. Before importing, it replaces process.stderr.write with a tee so every
+ * stderr byte the server writes is mirrored to the log sinks; stdin and stdout
+ * (the JSON-RPC channel) are never touched.
+ *
+ *   Claude Code CLI → shim (this file) = node running <real-entry> in-process
+ *        stdin/stdout : untouched (JSON-RPC channel)
+ *        stderr       : process.stderr.write teed → raw sink + passthrough
+ *
+ * Destinations:
+ *   - `${LOG_DIR}/mcp-<name>-<SESSION_ID>.log`   — raw stderr + lifecycle lines.
+ *     The sole raw sink. Task 1721 retired the per-date twin: its date was
+ *     pinned at spawn, no reader ever parsed it, and a since-removed stderr
+ *     tee wrote the same file, so every line landed twice.
+ *   - `${LOG_DIR}/mcp-<name>-nosession.log`      — the same, for a spawn with
+ *     no SESSION_ID (enumeration). One fixed file per server.
+ *   - `server.log` via the loopback log-ingest route — best-effort mirror of
+ *     the [mcp-helper] lifecycle lines.
+ *
+ * Lifecycle lines, correlation key `session=<id8> server=<name>` — unchanged:
+ *   [mcp-helper] op=spawn ... pid= entry=
+ *   [mcp-helper] op=boot  ... head=<first stderr bytes>
+ *   [mcp-helper] op=exit  ... code= signal= lifetimeMs= stderr-tail=
+ *
+ * Process model (Task 989): the shim IS the server's process. op=exit fires
+ * from process.on("exit"), so it covers a normal exit, a non-zero exit, an
+ * uncaught throw (code 1), and a catchable-signal exit (SIGTERM/SIGINT/SIGHUP,
+ * whose handlers record the signal name). An external SIGKILL is uncatchable
+ * and leaves no op=exit line — the per-session stderr tail already on disk and
+ * Claude Code's own transport-drop are the evidence for that death mode.
+ *
+ * The shim never writes to fd 1 (stdout) — that is the JSON-RPC channel.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_url_1 = require("node:url");
+const SERVER_NAME = process.env.MCP_SPAWN_TEE_NAME ?? "unknown";
+const LOG_DIR = process.env.LOG_DIR;
+const SESSION_ID = process.env.SESSION_ID;
+const PLATFORM_PORT = process.env.PLATFORM_PORT;
+const ENTRY = process.argv[2];
+const SESSION_ID8 = SESSION_ID ? SESSION_ID.slice(0, 8) : "—";
+const spawnStamp = Date.now();
+// The one raw sink (Task 1721). A sessionless spawn (rc-daemon stamps
+// SESSION_ID='' — rc-daemon.ts:513 — while still stamping LOG_DIR) shares one
+// fixed file per server rather than a date-named one: the date was never read
+// by any reader and named a process lifetime, not a day. Interleaved spawns in
+// the nosession file are separated by the [mcp-helper] op=spawn pid= lines.
+const rawSinkPath = LOG_DIR
+    ? (0, node_path_1.resolve)(LOG_DIR, SESSION_ID ? `mcp-${SERVER_NAME}-${SESSION_ID}.log` : `mcp-${SERVER_NAME}-nosession.log`)
+    : undefined;
+// Rolling tail of entry stderr for op=exit. Capped so a chatty server cannot
+// grow the buffer without bound.
+const TAIL_CAP = 2048;
+let stderrTail = "";
+let bootEmitted = false;
+let exitEmitted = false;
+let exitSignal;
+// The real stderr writer, captured before the tee replaces it. Lifecycle lines
+// and stderr passthrough both go through this so they are never re-teed into
+// the raw sink nor recursed back into the patched writer.
+const rawStderrWrite = process.stderr.write.bind(process.stderr);
+// LOG_DIR is created once, lazily, on the first successful append — not per
+// chunk. teeWrite runs on the server's own stderr hot path now, so a per-call
+// mkdirSync would be two syscalls per log line for nothing.
+let logDirReady = false;
+function appendSafe(path, data) {
+    if (!path || !LOG_DIR)
+        return;
+    try {
+        if (!logDirReady) {
+            (0, node_fs_1.mkdirSync)(LOG_DIR, { recursive: true });
+            logDirReady = true;
+        }
+        (0, node_fs_1.appendFileSync)(path, data);
+    }
+    catch {
+        /* unwritable destination — never mask primary output */
+    }
+}
+// Best-effort mirror of a lifecycle line to server.log via the loopback
+// log-ingest route. Fire-and-forget: the per-session file is authoritative, so
+// a dropped POST loses nothing. On the "exit" event the loop is stopping, so
+// the op=exit mirror may not flush — the per-session line, written sync, holds.
+function postToServerLog(suffix, level) {
+    if (!PLATFORM_PORT)
+        return;
+    try {
+        const ctrl = new AbortController();
+        const t = setTimeout(() => ctrl.abort(), 500);
+        t.unref?.(); // never let the abort timer keep the shim's event loop alive
+        void fetch(`http://127.0.0.1:${PLATFORM_PORT}/api/admin/log-ingest`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ tag: "mcp-helper", level, line: suffix }),
+            signal: ctrl.signal,
+        }).then(() => clearTimeout(t)).catch(() => clearTimeout(t));
+    }
+    catch {
+        /* fetch threw synchronously — best-effort only */
+    }
+}
+// Emit one [mcp-helper] lifecycle line: authoritative per-session file (sync,
+// survives process.exit), the shim's own stderr via the RAW writer (journald /
+// Claude Code visibility, never re-teed), and a best-effort server.log mirror.
+// `suffix` is the line body after the tag and carries no newline (the
+// log-ingest route rejects newlines).
+function emitLifecycle(suffix, level) {
+    const line = `[mcp-helper] ${suffix}\n`;
+    appendSafe(rawSinkPath, line);
+    try {
+        rawStderrWrite(line);
+    }
+    catch { /* stderr closed */ }
+    postToServerLog(suffix, level);
+}
+if (!ENTRY) {
+    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason="no entry given (argv[2] missing)"`, "error");
+    process.exit(2);
+}
+// Replace process.stderr.write with a tee: mirror every server stderr byte to
+// the raw sink, keep a rolling tail for op=exit, emit
+// op=boot on the first bytes, then pass the write through to the real stderr.
+const teeWrite = ((...args) => {
+    const chunk = args[0];
+    appendSafe(rawSinkPath, chunk); // raw sink (Task 1721)
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+    stderrTail = (stderrTail + text).slice(-TAIL_CAP);
+    if (!bootEmitted) {
+        bootEmitted = true;
+        const head = text.split("\n")[0].slice(0, 200);
+        emitLifecycle(`op=boot session=${SESSION_ID8} server=${SERVER_NAME} head=${JSON.stringify(head)}`, "info");
+    }
+    return rawStderrWrite(...args); // passthrough
+});
+process.stderr.write = teeWrite;
+// Catchable-signal handling. The shim drives the exit ONLY when it is the sole
+// listener for the signal — i.e. the imported entry installed no handler of its
+// own. In that case it records the signal (so op=exit carries signal=<sig>) and
+// exits with 128+signum, mirroring the prior wrapper's exit-status convention.
+//
+// When the entry DID install a handler, the shim defers entirely and records
+// nothing: the entry's handler decides the exit code, and op=exit reflects that
+// exit verbatim. This matches the prior two-process model, where a child that
+// caught the signal and exited cleanly was observed as code=0 signal=— (a clean
+// self-exit), not as a signal death. Setting exitSignal here unconditionally
+// would mislabel every graceful signal-driven shutdown as a signal kill.
+function onSignal(sig, code) {
+    return () => {
+        if (process.listenerCount(sig) === 1) {
+            exitSignal = sig;
+            process.exit(code);
+        }
+    };
+}
+process.on("SIGTERM", onSignal("SIGTERM", 143));
+process.on("SIGINT", onSignal("SIGINT", 130));
+process.on("SIGHUP", onSignal("SIGHUP", 129));
+// op=exit, emitted once from the process "exit" event. Sync-only — the loop is
+// stopping. When a catchable signal caused the exit, report code=— signal=<sig>
+// to match the prior wrapper's format; otherwise code=<exit code> signal=—.
+process.on("exit", (code) => {
+    if (exitEmitted)
+        return;
+    exitEmitted = true;
+    const lifetimeMs = Date.now() - spawnStamp;
+    const tail = stderrTail.slice(-200);
+    const codeField = exitSignal ? "—" : String(code);
+    const level = exitSignal || code !== 0 ? "error" : "info";
+    emitLifecycle(`op=exit session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} ` +
+        `code=${codeField} signal=${exitSignal ?? "—"} lifetimeMs=${lifetimeMs} stderr-tail=${JSON.stringify(tail)}`, level);
+});
+emitLifecycle(`op=spawn session=${SESSION_ID8} server=${SERVER_NAME} pid=${process.pid} entry=${ENTRY}`, "info");
+// Task 2356 — present argv as a direct `node <entry>` invocation before the
+// entry loads. The shim is meant to be transparent: an entry that asks the
+// standard "am I the entry module?" question
+// (`import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href`)
+// must get the same answer it gets when Claude Code runs it without the shim.
+// With the shim's own path left in argv[1] the answer is no, so such an entry
+// loads, starts nothing, and exits 0 — measured on the three channel servers,
+// which all gate main() that way. Plugin MCPs connect at module top level and
+// never read argv, so this is inert for them. ENTRY was captured above, before
+// the rewrite. Extra CLI args keep their positions after the entry slot.
+process.argv = [process.argv[0], ENTRY, ...process.argv.slice(3)];
+// Run the real MCP server in THIS process. Dynamic import() (not top-level
+// await — this file compiles to CommonJS) loads the ESM entry; a load-time
+// failure mirrors the old child spawn-error path (op=error, exit 127). The
+// op=exit handler is suppressed on this path so op=error stays the sole record.
+import((0, node_url_1.pathToFileURL)(ENTRY).href).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    exitEmitted = true;
+    emitLifecycle(`op=error session=${SESSION_ID8} server=${SERVER_NAME} reason=${JSON.stringify(`import error: ${msg}`)}`, "error");
+    process.exit(127);
+});
+//# sourceMappingURL=index.js.map

package/payload/platform/plugins/inventory/lib/mcp-spawn-tee/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/payload/platform/plugins/inventory/mcp/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/payload/platform/plugins/inventory/mcp/dist/index.d.ts.map

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