@rubytech/create-maxy-code 0.1.543 → 0.1.545

package/payload/platform/plugins/admin/skills/channel-instruction/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: channel-instruction
+description: "Set up or change what this account's agent does when a message arrives from someone who is not an account manager. Triggers when the owner says 'set up what my agent does with incoming messages', 'change how you handle WhatsApp messages from customers', 'write my channel instruction', 'my agent replied to a customer and it shouldn't have', or asks why an incoming message got no answer."
+---
+
+# Channel instruction
+
+Invoked by the admin agent directly.
+
+When someone who is not an account manager sends a WhatsApp message to this account's line, the platform wakes each manager's own session with a turn about it. That turn is handed a `## Context` block holding the message and an `## Instruction` block saying what to do with it. This skill is about the file that supplies the second block.
+
+## The file
+
+`$ACCOUNT_DIR/agents/admin/INSTRUCTION.md`
+
+Its whole body becomes the `## Instruction` block on that turn, verbatim. The platform wraps it in nothing and adds no wording of its own.
+
+The install creates the file empty. What goes in it is the account owner's, not the platform's.
+
+## Which turns it governs, and which it does not
+
+It governs one kind of turn: a WhatsApp message from someone who is not an account manager. Nothing else.
+
+**A message the owner sends is unaffected by this file.** Whether they type it in the admin webchat, send it from their own WhatsApp handset, or it arrives from the scheduler, the platform supplies its own directive for that turn and never reads this file. An instruction written here for handling a customer will not change how the agent answers the owner.
+
+**A public agent does not read this file either.** An account's public agent reads `$ACCOUNT_DIR/agents/<its-slug>/INSTRUCTION.md`, its own. Writing a rule here in the hope of steering the public agent does nothing.
+
+If the owner wants to change how the agent behaves toward them personally, this is the wrong file. Identity and manner live in `IDENTITY.md` and `SOUL.md` in the same directory, and they apply to every session.
+
+## An empty file drops the message
+
+A file that is missing, unreadable, or holds only whitespace resolves to absent, and an absent instruction refuses the turn: no session wakes, and nothing happens about the message. The sender gets silence and the owner is never told.
+
+Nothing warns the owner in advance. The only trace is two lines in `server.log`, written at the moment the message was dropped:
+
+- `op=instruction-source accountId=<id> turn=relay source=absent bytes=0`
+- `op=inbound … delivery=refused` for the same message
+
+So on an account whose WhatsApp line is connected and whose file is empty, writing this file is the fix for "a customer wrote in and nothing happened". If the owner reports that, check this file before anything else. Their own chat will be working normally throughout, which is what makes this hard to spot.
+
+## Writing it
+
+Read the file first and tell the owner what is in it. Then find out what they want and write it.
+
+What belongs in it is what should happen when a stranger writes in: who the agent may answer on its own and who it must not, what has to be put to a person, what it must never say, and what it must always do before the turn ends.
+
+Two rules on how you write it:
+
+- Write only what the owner has told you. A rule they did not ask for is someone else's wording in their file, which is exactly what this file exists to keep out.
+- Never carry rules over from another account or from another owner's file.
+
+An edit takes effect on the next incoming message. No restart, no upgrade, no publish. So a change can be checked by having someone message the account's WhatsApp line and reading what the agent does.
+
+## Checking which body a turn actually took
+
+Every WhatsApp turn writes one line to `server.log` naming the decision:
+
+`op=instruction-source accountId=<id> agentDir=<dir> turn=relay|direct|public source=account|platform|absent bytes=<n>`
+
+`turn=relay` with `source=account` means the turn took this file. `turn=direct` with `source=platform` means the owner sent it themselves and this file was not read. If the owner believes a rule they wrote is being applied to their own messages, that line settles it.

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:16c402596ec41a4862a881217aada22c79ea15e59da8e41c624a0ab494952fc9
+content-hash: sha256:4566431caa948d080401758fc742c6b3f6340a0a1d17129ff51c9887836aaf87
 brand: maxy-code
 product-name: Maxy
 ---
@@ -250,6 +250,7 @@ Inside the scope, `sh -c 'trap "" HUP; exec "$@"' sh <claudeBin> <args...>` keep
 | Step | Line shape |
 |------|-----------|
 | 1 | `[rc-spawn] op=request unitToken=<t> sessionId=<8|new> name=<…|none> mode=<resume|fresh> jsonl=<path|none>` |
+| 1b | `[rc-spawn] op=role-resolution sessionId=<8> source=<body\|sidecar\|unresolved> outcome=<ok\|missing\|parse-failed>` — channel-bound spawns only. `source` is where the session's role came from; `outcome` is the `readSidecar` verdict behind it, which separates a deleted classification sidecar from a corrupted one. `source=unresolved` means neither the body nor the sidecar produced a role, so the spawn took the public lockdown rather than running unrestricted. The `tool-allowlist` line cannot make that distinction: it renders `role=none` for an unresolved role and for a legitimately roleless spawn alike. |
 | 2 | `[rc-spawn] op=argv unitToken=<t> cwd=<dir> argv=<json>` (inner claude argv; the `systemd-run --scope` wrap is composed by the spawnPty adapter) |
 | 3 | `[rc-spawn] op=pty-spawned unitToken=<t> pid=<pid> openFds=<n>` (fd baseline) |
 | 4 | `[rc-spawn] op=child-output unitToken=<t> pid=<pid> head=<json>` (first ≤1 KB or 500 ms idle — claude's own words) |
@@ -1709,6 +1710,8 @@ Every turn carries a `source`. Three values exist:
 | `schedule` | The scheduler wrote this turn. The named destination did not send it. |
 | `public-relay` | The platform wrote this turn because a public visitor messaged the account. The named sender is a manager being told, not someone who wrote to you. |
 
+**A `public-relay` turn is the one turn whose `## Instruction` block is the account's own.** Its body is `agents/admin/INSTRUCTION.md`, written by the account owner, and it is the only instruction that turn carries: no standing-rules block rides with it. Every other turn on this line, including one the owner sent from their own handset and one the scheduler wrote, takes the platform's own directive and never reads that file. If the file is empty the relay turn is refused outright, so the message is dropped and nobody is told. A public visitor's own turn reads its agent's file at `agents/<slug>/INSTRUCTION.md`, never the admin's.
+
 A `public-relay` turn also says so in its own first two lines, and states which handset its reply tool reaches. That handset is the manager's, never the visitor's: the turn runs in the manager's own admin session, so a reply written to the visitor is delivered to the manager. If a turn claims a manager wrote something they plainly would not have written, check the source before answering them.
 
 **On a `public-relay` turn the reply tool is the only way to reach anyone.** On an ordinary turn the platform forwards your closing text to the sender when you called no reply tool. On a relay-woken turn it does not, because the relay carries its own reply path. So whatever you decide the manager should receive has to go through the reply tool; text you merely write at the end of the turn reaches nobody, and a decision not to reply is silence rather than a message.
@@ -5571,6 +5574,8 @@ The final step in the retrieval pipeline is injecting retrieved content into the
 
 The manager exposes three named spawn routes: `/rc-spawn` (a live `claude --remote-control` PTY — the operator sidebar, the channel admin, and the one-shot admin jobs), `/public-spawn` (the renamed `/spawn` — `spawnClaudeSession`, the zero-tool public surface), and the `rc-daemon` it drives. No route named `/spawn` remains; a manager boot line `[spawn-routes] live=[rc-spawn,public-spawn]` asserts this.
 
+**A public spawn may not name a specialist.** The zero-tool surface is built from four levers, and two of them — the `--allowed-tools` push and the resolved permission mode — branch on whether the spawn is a specialist rather than on whether it is public, so a specialist named on a public spawn would skip the allowlist entirely and resolve the caller's mode instead of the fail-closed `dontAsk`. Only the per-spawn `permissions.deny` and `--strict-mcp-config` bind on the public role alone. Neither production issuer sends the pairing: the channel bridge is the only caller whose role can be public and it carries no specialist field, while the cookie-auth session wrapper is admin-only. So the pairing is refused rather than reshaped — `/public-spawn` answers `400 specialist-not-permitted-on-public`, and `spawnClaudeSession` refuses it again with `reason=public-specialist-refused` at the single chokepoint every spawn route passes through. Refusing rather than narrowing the levers is deliberate: a narrowed lever would leave a specialist running silently on a one-tool surface. Every spawn that reaches `spawnClaudeSession` — which is every `/public-spawn`, that route being its only caller — logs the three deciding inputs together as `[spawn-lockdown] role=<role> specialist=<name|none> permissionMode=<mode>`. A refusal at either layer logs `op=public-specialist-refused` instead, told apart by `site=`.
+
 The channel PTY-bridge (`ensureEntry`) routes each inbound by role: an **admin** WhatsApp/Telegram inbound spawns on `/rc-spawn` (keyed by a deterministic per-sender sessionId so the thread resumes across restarts) and drives every turn via `/<id>/input`; a **non-admin** inbound spawns on `/public-spawn`. Each dispatch logs `[<channel>-adaptor] route role=<role> target=<rc-spawn|public-spawn> senderId=…`. LinkedIn ingest and the public session-end review also run on `/rc-spawn`, carrying their prompt as `initialMessage` with `closeAfterTurn` so the PTY stops after one assistant turn.
 
 ### Public agent paths

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

@@ -9,6 +9,18 @@ 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-02 (0.1.545)
+
+- The assistant is now instructed differently depending on whether you messaged it directly or the turn was relayed from someone outside your team, so your own standing rules no longer ride along on a relayed turn.
+- Publishing your booking availability now goes through Cloudflare's own interface rather than a command-line tool, and a retry that can no longer finish in time is refused instead of hanging.
+
+## 2026-08-02 (0.1.544)
+
+- Every channel, including Telegram, now takes its turn instruction from the account's own file rather than text fixed in the code, and a build check stops any of the three services hardcoding it again.
+- Each public agent now has its own instruction file, created on install.
+- A session whose role cannot be determined is now refused rather than allowed through, and a specialist can no longer be requested on a session serving someone outside your team.
+- A frozen session serving someone outside your team is now restarted through the same restricted route it began on.
+
 ## 2026-08-01 (0.1.543)
 
 - There is now a shared folder every account can read and only the main account can write to, and an upload route that could reach out of an account into it has been closed.

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

@@ -28,6 +28,8 @@ Every turn carries a `source`. Three values exist:
 | `schedule` | The scheduler wrote this turn. The named destination did not send it. |
 | `public-relay` | The platform wrote this turn because a public visitor messaged the account. The named sender is a manager being told, not someone who wrote to you. |
 
+**A `public-relay` turn is the one turn whose `## Instruction` block is the account's own.** Its body is `agents/admin/INSTRUCTION.md`, written by the account owner, and it is the only instruction that turn carries: no standing-rules block rides with it. Every other turn on this line, including one the owner sent from their own handset and one the scheduler wrote, takes the platform's own directive and never reads that file. If the file is empty the relay turn is refused outright, so the message is dropped and nobody is told. A public visitor's own turn reads its agent's file at `agents/<slug>/INSTRUCTION.md`, never the admin's.
+
 A `public-relay` turn also says so in its own first two lines, and states which handset its reply tool reaches. That handset is the manager's, never the visitor's: the turn runs in the manager's own admin session, so a reply written to the visitor is delivered to the manager. If a turn claims a manager wrote something they plainly would not have written, check the source before answering them.
 
 **On a `public-relay` turn the reply tool is the only way to reach anyone.** On an ordinary turn the platform forwards your closing text to the sender when you called no reply tool. On a relay-woken turn it does not, because the relay carries its own reply path. So whatever you decide the manager should receive has to go through the reply tool; text you merely write at the end of the turn reaches nobody, and a decision not to reply is silence rather than a message.

package/payload/platform/plugins/docs/references/internals.md

@@ -357,6 +357,8 @@ The final step in the retrieval pipeline is injecting retrieved content into the
 
 The manager exposes three named spawn routes: `/rc-spawn` (a live `claude --remote-control` PTY — the operator sidebar, the channel admin, and the one-shot admin jobs), `/public-spawn` (the renamed `/spawn` — `spawnClaudeSession`, the zero-tool public surface), and the `rc-daemon` it drives. No route named `/spawn` remains; a manager boot line `[spawn-routes] live=[rc-spawn,public-spawn]` asserts this.
 
+**A public spawn may not name a specialist.** The zero-tool surface is built from four levers, and two of them — the `--allowed-tools` push and the resolved permission mode — branch on whether the spawn is a specialist rather than on whether it is public, so a specialist named on a public spawn would skip the allowlist entirely and resolve the caller's mode instead of the fail-closed `dontAsk`. Only the per-spawn `permissions.deny` and `--strict-mcp-config` bind on the public role alone. Neither production issuer sends the pairing: the channel bridge is the only caller whose role can be public and it carries no specialist field, while the cookie-auth session wrapper is admin-only. So the pairing is refused rather than reshaped — `/public-spawn` answers `400 specialist-not-permitted-on-public`, and `spawnClaudeSession` refuses it again with `reason=public-specialist-refused` at the single chokepoint every spawn route passes through. Refusing rather than narrowing the levers is deliberate: a narrowed lever would leave a specialist running silently on a one-tool surface. Every spawn that reaches `spawnClaudeSession` — which is every `/public-spawn`, that route being its only caller — logs the three deciding inputs together as `[spawn-lockdown] role=<role> specialist=<name|none> permissionMode=<mode>`. A refusal at either layer logs `op=public-specialist-refused` instead, told apart by `site=`.
+
 The channel PTY-bridge (`ensureEntry`) routes each inbound by role: an **admin** WhatsApp/Telegram inbound spawns on `/rc-spawn` (keyed by a deterministic per-sender sessionId so the thread resumes across restarts) and drives every turn via `/<id>/input`; a **non-admin** inbound spawns on `/public-spawn`. Each dispatch logs `[<channel>-adaptor] route role=<role> target=<rc-spawn|public-spawn> senderId=…`. LinkedIn ingest and the public session-end review also run on `/rc-spawn`, carrying their prompt as `initialMessage` with `closeAfterTurn` so the PTY stops after one assistant turn.
 
 ### Public agent paths

package/payload/platform/plugins/docs/references/platform.md

@@ -123,6 +123,7 @@ Inside the scope, `sh -c 'trap "" HUP; exec "$@"' sh <claudeBin> <args...>` keep
 | Step | Line shape |
 |------|-----------|
 | 1 | `[rc-spawn] op=request unitToken=<t> sessionId=<8|new> name=<…|none> mode=<resume|fresh> jsonl=<path|none>` |
+| 1b | `[rc-spawn] op=role-resolution sessionId=<8> source=<body\|sidecar\|unresolved> outcome=<ok\|missing\|parse-failed>` — channel-bound spawns only. `source` is where the session's role came from; `outcome` is the `readSidecar` verdict behind it, which separates a deleted classification sidecar from a corrupted one. `source=unresolved` means neither the body nor the sidecar produced a role, so the spawn took the public lockdown rather than running unrestricted. The `tool-allowlist` line cannot make that distinction: it renders `role=none` for an unresolved role and for a legitimately roleless spawn alike. |
 | 2 | `[rc-spawn] op=argv unitToken=<t> cwd=<dir> argv=<json>` (inner claude argv; the `systemd-run --scope` wrap is composed by the spawnPty adapter) |
 | 3 | `[rc-spawn] op=pty-spawned unitToken=<t> pid=<pid> openFds=<n>` (fd baseline) |
 | 4 | `[rc-spawn] op=child-output unitToken=<t> pid=<pid> head=<json>` (first ≤1 KB or 500 ms idle — claude's own words) |

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

@@ -274,7 +274,7 @@ Dispatch results are recorded on the Event node (`lastDispatchResult`, `lastDisp
 
 It is **armed by the always-running `platform/ui` server on an interval**, because the Pi has no other periodic surface (the same gap `check-due-events` has). A PID lock at `<configDir>/reconcile-bookings.lock` prevents overlapping runs. It registers **no agent tool** — there is nothing for the agent to call — so the tool-surface registries are untouched.
 
-Env: `PLATFORM_ROOT`, `NEO4J_URI` (and `NEO4J_PASSWORD` or `config/.neo4j-password`). Per account it reads `data/accounts/<id>/calendar-availability.json` (for `bookingDbName`). The Cloudflare credential is read house-only from `config/cloudflare-house.env`; that credential is a minter, so the calendar mints a `calendar-d1` (D1-only) token from it via `cf-token.sh` and shells `wrangler` for the D1 reads/writes on that scoped token, never the minter directly.
+Env: `PLATFORM_ROOT`, `NEO4J_URI` (and `NEO4J_PASSWORD` or `config/.neo4j-password`). Per account it reads `data/accounts/<id>/calendar-availability.json` (for `bookingDbName`). The Cloudflare credential is read house-only from `config/cloudflare-house.env`; that credential is a minter, so the calendar mints a `calendar-d1` (D1-only) token from it via `cf-token.sh` and authenticates the D1 reads/writes on that scoped token, never the minter directly. Those reads and writes go over Cloudflare's D1 HTTP query API (`lib/d1-command.ts`), not a `wrangler` shell-out — no scheduling path shells a CLI, on this loop or on the availability publish. The bounds that the retired spawn carried survive as a 60 s per-request timeout and a 16 MB streamed response cap, and the endpoint is addressed per Cloudflare account, so `CLOUDFLARE_ACCOUNT_ID` is required rather than inferred.
 
 Observability: one `[calendar-booking]` line per step keyed by `bookingId` (`reconcile-claim`, `meeting-write`, `notify`, `booked`), and one `[calendar-reconcile] account=… eligibleExamined=… pendingUnreconciled=… pendingOldestAgeMin=… orphanMeetings=…` audit line per account per run. `eligibleExamined` separates "nothing to do" from "verified clean". A `pendingUnreconciled` that persists across runs means those rows are failing to become meetings rather than merely lagging — the `attempt=` count on the claim and failure lines says how many times each has been tried. `orphanMeetings` means a booking meeting has no backing eligible D1 row. `pendingOldestAgeMin` ages that backlog: a count cannot separate a short lag from a nine-hour one. The companion `[calendar-reconcile] op=liveness lastRunAgeMin=… lastAuditAgeMin=… lastSkipReason=… stale=<bool>` line is emitted every ten minutes by the platform/ui server rather than by this script, because the failure it detects is this script not reporting at all. `op=liveness-write-failed` is the one case where that record could not be written; it carries the error body and never stops the run, because a run that worked must not be reported as failed for losing its own bookkeeping.
 

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/availability-snapshot.test.d.ts

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

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/availability-snapshot.test.d.ts.map

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

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/availability-snapshot.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import { writeSnapshot, MAX_ATTEMPTS, RETRY_START_DEADLINE_MS, SNAPSHOT_TABLE_DDL, SNAPSHOT_UPSERT_SQL, } from "../availability-snapshot.js";
+/** A D1Client that records every statement and rejects the first `failFirstN`. */
+function fakeClient(failFirstN = 0) {
+    const issued = [];
+    let failuresLeft = failFirstN;
+    return {
+        issued,
+        async query(dbName, sql, params = []) {
+            issued.push({ dbName, sql, params });
+            if (failuresLeft > 0) {
+                failuresLeft--;
+                throw new Error('scheduling: d1 query failed: 500\n{"errors":[{"code":7500}]}');
+            }
+            return [];
+        },
+        get statements() {
+            return issued.length;
+        },
+        get elapsedMs() {
+            return 42;
+        },
+    };
+}
+describe("writeSnapshot", () => {
+    it("issues the schema statement then the upsert, and reports one attempt", async () => {
+        const client = fakeClient();
+        const result = await writeSnapshot(client, "maxy-bookings", '{"slots":[]}', "2026-08-02T06:00:00.000Z");
+        expect(result.ok).toBe(true);
+        expect(result.attempts).toBe(1);
+        expect(result.elapsedMs).toBe(42);
+        expect(client.issued).toHaveLength(2);
+        expect(client.issued[0].sql).toBe(SNAPSHOT_TABLE_DDL);
+        expect(client.issued[1].sql).toBe(SNAPSHOT_UPSERT_SQL);
+        expect(client.issued[0].dbName).toBe("maxy-bookings");
+    });
+    it("binds the payload and updatedAt rather than interpolating them", async () => {
+        const client = fakeClient();
+        // A quote is the exact character the retired string-escaping path hand-handled.
+        const payload = `{"note":"it's fine"}`;
+        await writeSnapshot(client, "maxy-bookings", payload, "2026-08-02T06:00:00.000Z");
+        expect(client.issued[1].params).toEqual([payload, "2026-08-02T06:00:00.000Z"]);
+        expect(client.issued[1].sql).not.toContain("it's fine");
+        expect(client.issued[1].sql).toContain("?1");
+        expect(client.issued[1].sql).toContain("?2");
+    });
+    it("retries the whole pair once and succeeds on the second attempt", async () => {
+        const client = fakeClient(1);
+        const result = await writeSnapshot(client, "maxy-bookings", '{"slots":[]}', "2026-08-02T06:00:00.000Z");
+        expect(result.ok).toBe(true);
+        expect(result.attempts).toBe(2);
+        expect(result.error).toBeUndefined();
+        // Attempt 1 issued only the DDL before it threw; attempt 2 issued both.
+        expect(client.issued).toHaveLength(3);
+        expect(client.issued[1].sql).toBe(SNAPSHOT_TABLE_DDL);
+        expect(client.issued[2].sql).toBe(SNAPSHOT_UPSERT_SQL);
+    });
+    it("refuses the retry when the first attempt ran past the deadline", async () => {
+        const client = fakeClient(Number.MAX_SAFE_INTEGER);
+        // A clock that jumps the deadline between the start reading and the check.
+        // Without the guard a second attempt would start here and could hold the
+        // per-account lock into the next 300 s tick.
+        const readings = [0, RETRY_START_DEADLINE_MS];
+        let i = 0;
+        const now = () => readings[Math.min(i++, readings.length - 1)];
+        const result = await writeSnapshot(client, "maxy-bookings", '{"slots":[]}', "2026-08-02T06:00:00.000Z", now);
+        expect(result.ok).toBe(false);
+        expect(result.attempts).toBe(1);
+        expect(client.issued).toHaveLength(1);
+    });
+    it("gives up after MAX_ATTEMPTS and carries the last error", async () => {
+        const client = fakeClient(Number.MAX_SAFE_INTEGER);
+        const result = await writeSnapshot(client, "maxy-bookings", '{"slots":[]}', "2026-08-02T06:00:00.000Z");
+        expect(result.ok).toBe(false);
+        expect(result.attempts).toBe(MAX_ATTEMPTS);
+        expect(result.error).toContain("d1 query failed: 500");
+        expect(client.issued).toHaveLength(MAX_ATTEMPTS);
+    });
+});
+//# sourceMappingURL=availability-snapshot.test.js.map

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/availability-snapshot.test.js.map

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

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/publish-availability-logging.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=publish-availability-logging.test.d.ts.map

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/publish-availability-logging.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-availability-logging.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/publish-availability-logging.test.ts"],"names":[],"mappings":""}

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/publish-availability-logging.test.js

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+/**
+ * The dispatcher's lines are its only signal, and the server spawns it with
+ * `stdio: 'inherit'`, so an undated line lands in server.log beside the
+ * server's own dated ones and cannot be attributed to a tick without counting
+ * neighbouring lines.
+ *
+ * Asserted against the source rather than by running the script: `main()`
+ * executes on import, so there is no way to import this module and observe its
+ * output without also performing a publish.
+ */
+const SOURCE = readFileSync(resolve(__dirname, "../../scripts/publish-availability.ts"), "utf-8");
+/** The source with comments stripped, so a comment describing the retired
+ *  approach is never mistaken for the approach still being in use. */
+const CODE = SOURCE.replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*\/\/.*$/gm, "");
+describe("publish-availability logging", () => {
+    it("writes to stderr in exactly one place, the dated log helper", () => {
+        // One call site means every emission is dated by construction: there is no
+        // second path to stderr for a future line to take.
+        expect(CODE.match(/console\.error\(/g) ?? []).toHaveLength(1);
+        expect(CODE).toContain("function log(line: string): void {\n  console.error(`${new Date().toISOString()} ${line}`);");
+    });
+    it("no longer shells a CLI or stages a temp SQL file", () => {
+        expect(CODE).not.toMatch(/\bspawnSync\s*\(/);
+        expect(CODE).not.toMatch(/\bmkdtempSync\s*\(|\brmSync\s*\(|\btmpdir\s*\(/);
+        expect(CODE).not.toMatch(/["']wrangler["']/);
+        expect(CODE).not.toMatch(/node:child_process/);
+    });
+});
+//# sourceMappingURL=publish-availability-logging.test.js.map

package/payload/platform/plugins/scheduling/mcp/dist/lib/__tests__/publish-availability-logging.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-availability-logging.test.js","sourceRoot":"","sources":["../../../src/lib/__tests__/publish-availability-logging.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;;;;;;GASG;AACH,MAAM,MAAM,GAAG,YAAY,CACzB,OAAO,CAAC,SAAS,EAAE,uCAAuC,CAAC,EAC3D,OAAO,CACR,CAAC;AAEF;sEACsE;AACtE,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAC;AAElF,QAAQ,CAAC,8BAA8B,EAAE,GAAG,EAAE;IAC5C,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;QACrE,2EAA2E;QAC3E,mDAAmD;QACnD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,CACpB,6FAA6F,CAC9F,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC1D,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;QAC7C,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,gDAAgD,CAAC,CAAC;QAC3E,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC;QAC7C,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/payload/platform/plugins/scheduling/mcp/dist/lib/availability-snapshot.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The booking page's availability snapshot: its schema statement, its upsert,
+ * and the bounded write that issues both.
+ *
+ * Task 2349 — this write used to be `npx wrangler d1 execute` run through
+ * spawnSync from the publish dispatcher. That spawn's own 60 s timeout killed a
+ * slow write with SIGTERM, and the failure branch logged only `status` and
+ * `signal` while discarding the stderr it had captured, so a killed write could
+ * not be told from a rejected one. Task 1805 had already replaced the same
+ * spawn on the reconcile loop with the D1 HTTP client and scoped this caller
+ * out as "not on this loop"; this completes that migration.
+ *
+ * The payload is bound, never interpolated. The retired path hand-escaped
+ * single quotes into the statement text, which is a correctness burden this
+ * transport removes rather than reimplements.
+ */
+import type { D1Client } from "./d1-command.js";
+/** Attempts one write gets. */
+export declare const MAX_ATTEMPTS = 2;
+/**
+ * How late a failed attempt may be and still earn a retry.
+ *
+ * The ceiling here is not the obvious one. `D1_TIMEOUT_MS` binds a single
+ * REQUEST, not an attempt, and one attempt issues up to three of them (name
+ * lookup, schema, upsert). Two unguarded attempts therefore reach ~300 s, which
+ * IS the publish interval: the run would still hold the per-account PID lock
+ * when the next tick spawns, that tick would skip with reason=lock-held, and a
+ * retry meant to save one interval would instead have cost two.
+ *
+ * A second attempt is two requests once the name lookup has cached, so 120 s.
+ * Refusing to start one after this point holds the whole write under ~240 s and
+ * guarantees the lock is released before the next tick. The realistic failures
+ * sit nowhere near it — a timing-out statement fails its attempt at ~60 s — so
+ * this forfeits no retry that was going to help.
+ */
+export declare const RETRY_START_DEADLINE_MS = 120000;
+/**
+ * Self-healing schema. A booking site provisioned before the snapshot feature
+ * has a `bookings` table but no `availability_snapshot`; issuing this first
+ * means the table appears on the next publish rather than waiting for a skill
+ * re-run.
+ */
+export declare const SNAPSHOT_TABLE_DDL = "CREATE TABLE IF NOT EXISTS availability_snapshot (\n  id        INTEGER PRIMARY KEY CHECK (id = 1),\n  payload   TEXT,\n  updatedAt TEXT\n)";
+/** One row, id 1, replaced in place on every publish. */
+export declare const SNAPSHOT_UPSERT_SQL = "INSERT INTO availability_snapshot (id, payload, updatedAt)\nVALUES (1, ?1, ?2)\nON CONFLICT(id) DO UPDATE SET payload=excluded.payload, updatedAt=excluded.updatedAt";
+export interface SnapshotWriteResult {
+    ok: boolean;
+    /** Attempts actually made. Never a retry that the deadline refused. */
+    attempts: number;
+    /** Total wall time spent in D1 across every attempt, the client's own figure. */
+    elapsedMs: number;
+    /** The last failure's message. Absent when ok. */
+    error?: string;
+}
+/**
+ * Write the snapshot, retrying the whole pair once while there is time for it.
+ *
+ * Both statements retry together rather than only the upsert: the DDL is
+ * IF NOT EXISTS so re-issuing it costs nothing, and one client across both
+ * attempts reuses its cached database-name lookup instead of paying for it
+ * twice.
+ *
+ * Returns a result rather than throwing so the caller's success and failure log
+ * lines read straight off it, carrying the same fields either way.
+ */
+export declare function writeSnapshot(client: D1Client, dbName: string, payload: string, updatedAt: string, now?: () => number): Promise<SnapshotWriteResult>;
+//# sourceMappingURL=availability-snapshot.d.ts.map

package/payload/platform/plugins/scheduling/mcp/dist/lib/availability-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability-snapshot.d.ts","sourceRoot":"","sources":["../../src/lib/availability-snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,+BAA+B;AAC/B,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,uBAAuB,SAAU,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,gJAI7B,CAAC;AAEH,yDAAyD;AACzD,eAAO,MAAM,mBAAmB,yKAEqD,CAAC;AAEtF,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,OAAO,CAAC;IACZ,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,SAAS,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EAIjB,GAAG,GAAE,MAAM,MAAiB,GAC3B,OAAO,CAAC,mBAAmB,CAAC,CAmB9B"}

package/payload/platform/plugins/scheduling/mcp/dist/lib/availability-snapshot.js

@@ -0,0 +1,88 @@
+/**
+ * The booking page's availability snapshot: its schema statement, its upsert,
+ * and the bounded write that issues both.
+ *
+ * Task 2349 — this write used to be `npx wrangler d1 execute` run through
+ * spawnSync from the publish dispatcher. That spawn's own 60 s timeout killed a
+ * slow write with SIGTERM, and the failure branch logged only `status` and
+ * `signal` while discarding the stderr it had captured, so a killed write could
+ * not be told from a rejected one. Task 1805 had already replaced the same
+ * spawn on the reconcile loop with the D1 HTTP client and scoped this caller
+ * out as "not on this loop"; this completes that migration.
+ *
+ * The payload is bound, never interpolated. The retired path hand-escaped
+ * single quotes into the statement text, which is a correctness burden this
+ * transport removes rather than reimplements.
+ */
+/** Attempts one write gets. */
+export const MAX_ATTEMPTS = 2;
+/**
+ * How late a failed attempt may be and still earn a retry.
+ *
+ * The ceiling here is not the obvious one. `D1_TIMEOUT_MS` binds a single
+ * REQUEST, not an attempt, and one attempt issues up to three of them (name
+ * lookup, schema, upsert). Two unguarded attempts therefore reach ~300 s, which
+ * IS the publish interval: the run would still hold the per-account PID lock
+ * when the next tick spawns, that tick would skip with reason=lock-held, and a
+ * retry meant to save one interval would instead have cost two.
+ *
+ * A second attempt is two requests once the name lookup has cached, so 120 s.
+ * Refusing to start one after this point holds the whole write under ~240 s and
+ * guarantees the lock is released before the next tick. The realistic failures
+ * sit nowhere near it — a timing-out statement fails its attempt at ~60 s — so
+ * this forfeits no retry that was going to help.
+ */
+export const RETRY_START_DEADLINE_MS = 120_000;
+/**
+ * Self-healing schema. A booking site provisioned before the snapshot feature
+ * has a `bookings` table but no `availability_snapshot`; issuing this first
+ * means the table appears on the next publish rather than waiting for a skill
+ * re-run.
+ */
+export const SNAPSHOT_TABLE_DDL = `CREATE TABLE IF NOT EXISTS availability_snapshot (
+  id        INTEGER PRIMARY KEY CHECK (id = 1),
+  payload   TEXT,
+  updatedAt TEXT
+)`;
+/** One row, id 1, replaced in place on every publish. */
+export const SNAPSHOT_UPSERT_SQL = `INSERT INTO availability_snapshot (id, payload, updatedAt)
+VALUES (1, ?1, ?2)
+ON CONFLICT(id) DO UPDATE SET payload=excluded.payload, updatedAt=excluded.updatedAt`;
+/**
+ * Write the snapshot, retrying the whole pair once while there is time for it.
+ *
+ * Both statements retry together rather than only the upsert: the DDL is
+ * IF NOT EXISTS so re-issuing it costs nothing, and one client across both
+ * attempts reuses its cached database-name lookup instead of paying for it
+ * twice.
+ *
+ * Returns a result rather than throwing so the caller's success and failure log
+ * lines read straight off it, carrying the same fields either way.
+ */
+export async function writeSnapshot(client, dbName, payload, updatedAt, 
+// Injectable so the retry deadline is reachable from a test rather than only
+// from a real two-minute wall-clock wait. The same seam d1-command.ts gives
+// its transport.
+now = Date.now) {
+    const startedAt = now();
+    let lastError = "";
+    let attempts = 0;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        attempts = attempt;
+        try {
+            await client.query(dbName, SNAPSHOT_TABLE_DDL);
+            await client.query(dbName, SNAPSHOT_UPSERT_SQL, [payload, updatedAt]);
+            return { ok: true, attempts, elapsedMs: client.elapsedMs };
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err.message : String(err);
+            // Too late to start another one. Reported as the attempts actually made,
+            // never as MAX_ATTEMPTS, so the log line cannot claim a retry that was
+            // refused.
+            if (now() - startedAt >= RETRY_START_DEADLINE_MS)
+                break;
+        }
+    }
+    return { ok: false, attempts, elapsedMs: client.elapsedMs, error: lastError };
+}
+//# sourceMappingURL=availability-snapshot.js.map

package/payload/platform/plugins/scheduling/mcp/dist/lib/availability-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"availability-snapshot.js","sourceRoot":"","sources":["../../src/lib/availability-snapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,+BAA+B;AAC/B,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC;AAE9B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,OAAO,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;EAIhC,CAAC;AAEH,yDAAyD;AACzD,MAAM,CAAC,MAAM,mBAAmB,GAAG;;qFAEkD,CAAC;AAYtF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,MAAgB,EAChB,MAAc,EACd,OAAe,EACf,SAAiB;AACjB,6EAA6E;AAC7E,4EAA4E;AAC5E,iBAAiB;AACjB,MAAoB,IAAI,CAAC,GAAG;IAE5B,MAAM,SAAS,GAAG,GAAG,EAAE,CAAC;IACxB,IAAI,SAAS,GAAG,EAAE,CAAC;IACnB,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,YAAY,EAAE,OAAO,EAAE,EAAE,CAAC;QACzD,QAAQ,GAAG,OAAO,CAAC;QACnB,IAAI,CAAC;YACH,MAAM,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;YAC/C,MAAM,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC;YACtE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC;QAC7D,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,SAAS,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC7D,yEAAyE;YACzE,uEAAuE;YACvE,WAAW;YACX,IAAI,GAAG,EAAE,GAAG,SAAS,IAAI,uBAAuB;gBAAE,MAAM;QAC1D,CAAC;IACH,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;AAChF,CAAC"}

package/payload/platform/plugins/scheduling/mcp/dist/scripts/publish-availability.d.ts

@@ -18,7 +18,8 @@
  * overlapping runs. Each run records the outcome to a local last-publish.json so
  * the server's audit tick can report snapshot age independent of this job.
  *
- * Observability — one [calendar-availability] op=publish line per run.
+ * Observability — one dated [calendar-availability] op=publish line per run,
+ * carrying d1Ms (time in D1, the bound is 60 s) and attempt (1 or 2).
  *
  *   PLATFORM_ROOT=... MAXY_UI_INTERNAL_PORT=... PUBLISH_ACCOUNT_DIR=... \
  *   PUBLISH_ACCOUNT_ID=... node dist/scripts/publish-availability.js

package/payload/platform/plugins/scheduling/mcp/dist/scripts/publish-availability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publish-availability.d.ts","sourceRoot":"","sources":["../../src/scripts/publish-availability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG"}
+{"version":3,"file":"publish-availability.d.ts","sourceRoot":"","sources":["../../src/scripts/publish-availability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}