@rubytech/create-sitedesk-code 0.1.522 → 0.1.523

package/payload/platform/lib/routine-templates/dist/roster.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Task 2130 — the shipped routine roster.
+ *
+ * A fresh install used to ship zero routines, so the only working examples
+ * lived in one customer's graph and every operator wrote the prompts from
+ * scratch. These eleven are the catalogue that ships with the platform instead.
+ *
+ * Two properties make a routine shippable, and both are load-bearing:
+ *
+ *   1. It resolves its own surfaces at run time. Every prompt opens on
+ *      `capabilities-here`, which reports the account's live install set, and
+ *      ends the turn without replying when the surface it needs is absent. That
+ *      is what makes the same eleven rows correct on an estate agency, a web studio
+ *      and a field-service install rather than a template someone must edit.
+ *
+ *   2. It names nobody. No prompt carries a person's name, an email address, a
+ *      phone number, a hostname or a database name. `scripts/check-routine-
+ *      templates-generic.sh` is the standing control for that; a review pass is
+ *      not, because the failure is silent and the routine still works.
+ *
+ * The `recurrence` on each row is a PROPOSAL, not a schedule. Seeded rows carry
+ * `eventStatus:'suspended'` and `nextRun:NULL`, so nothing here fires until an
+ * operator enables it and supplies the cron and zone they actually want (see
+ * `.docs/routine-roster.md` for why the enable path takes all four arguments).
+ *
+ * Every tool name cited in a prompt exists in
+ * `platform/services/claude-session-manager/src/canonical-tool-names.generated.ts`.
+ * The roster test asserts that, so a renamed tool breaks the build rather than
+ * shipping a prompt that reaches for a tool no install serves.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROUTINE_ROSTER_KEYS = exports.ROUTINE_ROSTER = exports.ROUTINE_TEMPLATE_VERSION = void 0;
+/** Bumped whenever any prompt in the roster changes. The seed refreshes a
+ *  routine's prompt only when the stored `routineTemplateVersion` is BELOW this
+ *  and no operator has edited the row, so an unbumped edit ships to new installs
+ *  and never reaches existing ones — bump it in the same commit as the edit. */
+exports.ROUTINE_TEMPLATE_VERSION = 1;
+const START_OF_DAY = `Prepare the operator's morning briefing and reply with it as a single message.
+
+Call capabilities-here first and work only with the plugins it reports as enabled. Nothing below is mandatory: each part is included when its surface is present and skipped in silence when it is not.
+
+Mail: read today's unread and overnight messages with email-read, or outlook-mail-list when the mailbox is on the Microsoft side. Report what actually needs the operator, not a count.
+Diary: list today's appointments with outlook-calendar-list or google-calendar-list, plus schedule-list for anything booked in the graph rather than a provider calendar.
+Work: list what is open and due today or overdue with work-list.
+Connected systems: if a connector is registered, call connector-call for whatever it treats as today's queue.
+
+Write it the way a colleague would say it out loud: what needs a decision, what is time-bound, what changed overnight. Lead with the thing that will cost the most if it is missed. No headings, no counts for their own sake, no restating the sections above.
+
+If every surface is absent, or every surface is present and there is genuinely nothing worth saying, end the turn without replying. A silent morning is a correct result and is better than a message that says there is nothing to report.`;
+const INBOUND_CHECK = `Triage inbound messages that arrived since the last check and prepare replies for the operator to approve. Never send anything.
+
+Call capabilities-here first. If no mail plugin is enabled, end the turn without replying.
+
+Search for messages received since the previous run with email-search, or outlook-mail-search on the Microsoft side. Ignore anything already answered, anything automated, and anything the operator has clearly seen.
+
+For each message that genuinely needs a human reply, write a draft with email-draft or outlook-draft. Drafts only: this routine has no authority to send, and a sent message it should not have sent cannot be recalled. Match the operator's usual register from the surrounding thread rather than a house style.
+
+When a message commits the business to doing something rather than to saying something, record it with work-create so the obligation survives the inbox.
+
+Reply with one short message naming what you drafted and what you deliberately left alone, so the operator can open the drafts and send them. If there was nothing new that needed a reply, end the turn without replying.`;
+const END_OF_DAY = `Close the operator's day and reply with a single message.
+
+Call capabilities-here first and include only the parts whose surface is enabled.
+
+Waiting on the operator: list unsent drafts with email-draft-list. A draft written today and still unsent is the single most common thing that falls through, so name each one.
+Overdue: list work that is past due or due today and still open with work-list.
+Tomorrow: list tomorrow's appointments with outlook-calendar-list or google-calendar-list, and schedule-list for anything booked in the graph.
+
+Say what is unfinished and what tomorrow looks like, in that order, in plain sentences. Do not congratulate, do not summarise the day back, do not pad the message to look thorough.
+
+If nothing is waiting, nothing is overdue and tomorrow is empty, end the turn without replying.`;
+const APPOINTMENT_REMINDER = `Remind the people attending an appointment that is coming up, so nobody is reminded twice and nobody is missed.
+
+Call capabilities-here first. If neither a mail plugin nor a messaging channel is enabled, end the turn without replying.
+
+Find appointments starting within the next reminder window with schedule-list, and read each one's attendees. Resolve each attendee to a person and a contact route with contact-lookup. An attendee you cannot resolve to a route is not a failure to work around: leave them, and say so at the end.
+
+Send each attendee one reminder on the route they are already reachable on: email-send for a mailbox, whatsapp-reply or the Telegram message tool for a messaging thread that already exists. Carry the time, the place and what the appointment is about. Do not open a new conversation with someone who has never messaged the business.
+
+Send at most one reminder per attendee per appointment. Before sending, check the appointment's notes for a reminder already recorded, and record the one you send there.
+
+Reply with one line naming who was reminded and who could not be reached. If no appointment falls in the window, end the turn without replying.`;
+const COMMITMENT_CHASE = `Find the promises the business has made and not kept, and the promises made to it that nobody has kept.
+
+Call capabilities-here first and use only the surfaces it reports.
+
+Outbound: search sent mail with email-search for messages where the business undertook to do something, and check whether the thing happened. A promise with a date attached and no follow-up is the case worth surfacing.
+Inbound: find threads where the business asked for something and received no reply. Age matters more than volume; a three-week silence is worth naming and a two-day one is not.
+Work: list items past their due date with work-list.
+Context: check memory-search for what was previously agreed before deciding something has been dropped, so a commitment already met elsewhere is not chased again.
+
+Reply with the short list, each item saying what was promised, by whom, and how long it has been outstanding. Judgement is the point here, not coverage: three real items beat thirty possible ones.
+
+If nothing has been dropped, end the turn without replying.`;
+const CALENDAR_RECONCILE = `Reconcile the provider calendars against the appointments held in the graph, so the operator's diary and the agent's view of it are the same diary.
+
+Call capabilities-here first. If no calendar surface is enabled, end the turn without replying.
+
+Read the provider side with outlook-calendar-list or google-calendar-list, and the graph side with schedule-list, over the same window. Compare them.
+
+An appointment on the provider calendar with no counterpart in the graph is invisible to every other routine: write it with schedule-event. An appointment in the graph that has been cancelled provider-side should be marked cancelled, not deleted, so its history survives. Where the two disagree on time or attendees, the provider calendar is authoritative, because that is the one the operator edits.
+
+If the account has a busy-time sync configured, run schedule-connector-busy-sync so availability reflects what was just reconciled.
+
+Reply only when something was actually changed, naming what and why. A clean reconcile ends the turn without replying, every time. This routine runs often, so a message on every clean run trains the operator to ignore it.`;
+const CONTACT_RECONCILE = `Reconcile the people the business actually deals with against the people it has recorded.
+
+Call capabilities-here first. If neither a mail plugin nor the contacts plugin is enabled, end the turn without replying.
+
+Find the counterparties in recent correspondence with email-graph-query, and on the Microsoft side read the address book with outlook-contacts-list. Read the recorded people with contact-list.
+
+Someone corresponded with repeatedly and never recorded should be created with contact-create. Someone recorded with a stale route, a changed employer or a missing name should be updated with contact-update, taking the newer value from the correspondence.
+
+Two rules keep this from making the graph worse. A single inbound message is not a relationship, so do not create a contact from one. And two records that look like the same person may be two people, so surface the possible duplicate rather than merging it.
+
+Reply only when records were created or updated, naming the counts and anything ambiguous you left alone. A clean reconcile ends the turn without replying.`;
+const CRM_RECONCILE = `Reconcile whatever operational system this business runs against the graph, so the agent answers from the same records the operator works in.
+
+Call capabilities-here first and read the registered connectors with connector-register. If none is registered, end the turn without replying. This routine is deliberately unopinionated about which system that is: read what the connector actually exposes rather than assuming a shape.
+
+Pull the records that changed since the last run with connector-call. For each, decide whether the graph already holds it. Write what is genuinely new or genuinely changed with memory-write, and leave the rest alone.
+
+The connector is the system of record. Where the graph disagrees, the graph is stale and the connector wins. Never write back to the connector from here: this routine reads.
+
+Reply only when something changed, in one or two lines. A run with nothing to bring across ends the turn without replying.`;
+const FINANCE_RECONCILE = `Reconcile the accounting system against the ledger held in the graph.
+
+Call capabilities-here first. If no accounting connector is enabled, end the turn without replying.
+
+Read the accounting side with quickbooks-query over the period since the last run. Reconcile it against the internal ledger with ledger-reconcile, then read the resulting position with ledger-balance.
+
+Report only what an operator would act on: entries present on one side and not the other, amounts that disagree, and anything unreconciled long enough to be a problem rather than a timing difference. A difference explained by a payment still clearing is not a discrepancy.
+
+Never adjust an entry to make the two sides agree. An unexplained difference is the finding; silencing it destroys the only evidence that something is wrong.
+
+Reply with the discrepancies and the closing position. If everything reconciles, end the turn without replying.`;
+const WEEKLY_DIGEST = `Write the week in review and reply with it as a single message.
+
+Call capabilities-here first and cover only the surfaces that are enabled.
+
+Correspondence: what came in and what went out that mattered, from email-search or outlook-mail-search across the week.
+Diary: what happened and what is coming, from outlook-calendar-list, google-calendar-list and schedule-list.
+Work: what was completed, what slipped, what is still open, from work-list.
+Systems: if a connector is registered, what changed in it over the week, from connector-call.
+Context: check memory-search for what was said last week, so the digest reports movement rather than restating a standing position.
+
+This is the one routine written for a person with a few minutes, not for completeness. Say what changed, what is stuck, and what next week turns on. Three paragraphs at most. No section headings, no counts presented as achievements, no restating the categories above.
+
+If the week was genuinely empty, end the turn without replying.`;
+const CHANNEL_LINK_CHECK = `Check whether the business's messaging links are still up, and speak only when one is down.
+
+Call capabilities-here first. If no messaging channel is enabled, end the turn without replying.
+
+Read the link state with whatsapp-status. It reports, per link, whether it is connected, the number it is paired to, how many reconnect attempts it has made, and the error it last failed on.
+
+If every link is connected, end the turn without replying. A message on a healthy check is what trains an operator to ignore this routine, and an ignored check is worth less than no check.
+
+When a link is down, reply with one message naming the number it is paired to, the exact error it last reported, and how long it has been down. Say plainly whether the platform is still retrying it or has stopped. A link that was logged out, or replaced by another device, will not come back on its own: re-pairing needs someone holding the phone, so say that rather than implying it will recover by itself.
+
+Never disconnect a link and never begin a re-pair from here. This routine reports; the remedy is a person's decision.`;
+/** The eleven. Order is the display order on `/routines` before the operator
+ *  retimes anything: the daily rhythm first, then the reconciles, then the
+ *  weekly, then the standing check. */
+exports.ROUTINE_ROSTER = [
+    { key: "start-of-day", name: "Start of day briefing", recurrence: "30 7 * * 1-5", prompt: START_OF_DAY },
+    { key: "inbound-check", name: "Working-hours inbound check", recurrence: "*/30 9-17 * * 1-5", prompt: INBOUND_CHECK },
+    { key: "end-of-day", name: "End of day wrap-up", recurrence: "0 18 * * 1-5", prompt: END_OF_DAY },
+    { key: "appointment-reminder", name: "Appointment reminders", recurrence: "0 * * * *", prompt: APPOINTMENT_REMINDER },
+    { key: "commitment-chase", name: "Commitment chase", recurrence: "0 10 * * 2", prompt: COMMITMENT_CHASE },
+    { key: "calendar-reconcile", name: "Calendar reconcile", recurrence: "15 */4 * * *", prompt: CALENDAR_RECONCILE },
+    { key: "contact-reconcile", name: "Contact reconcile", recurrence: "45 6 * * 1-5", prompt: CONTACT_RECONCILE },
+    { key: "crm-reconcile", name: "Operational system reconcile", recurrence: "0 3 * * *", prompt: CRM_RECONCILE },
+    { key: "finance-reconcile", name: "Finance reconcile", recurrence: "0 4 * * 1", prompt: FINANCE_RECONCILE },
+    { key: "weekly-digest", name: "Weekly digest", recurrence: "0 16 * * 5", prompt: WEEKLY_DIGEST },
+    { key: "channel-link-check", name: "Channel link check", recurrence: "*/15 * * * *", prompt: CHANNEL_LINK_CHECK },
+];
+/** Every roster key, in roster order. The scheduling heartbeat's `op=roster`
+ *  drift check reconciles this expected set against what is actually in the
+ *  graph, so it is exported rather than re-derived there. */
+exports.ROUTINE_ROSTER_KEYS = exports.ROUTINE_ROSTER.map((r) => r.key);
+//# sourceMappingURL=roster.js.map

package/payload/platform/lib/routine-templates/dist/roster.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roster.js","sourceRoot":"","sources":["../src/roster.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;;;AAEH;;;gFAGgF;AACnE,QAAA,wBAAwB,GAAG,CAAC,CAAC;AAgB1C,MAAM,YAAY,GAAG;;;;;;;;;;;4OAWuN,CAAC;AAE7O,MAAM,aAAa,GAAG;;;;;;;;;;2NAUqM,CAAC;AAE5N,MAAM,UAAU,GAAG;;;;;;;;;;gGAU6E,CAAC;AAEjG,MAAM,oBAAoB,GAAG;;;;;;;;;;gJAUmH,CAAC;AAEjJ,MAAM,gBAAgB,GAAG;;;;;;;;;;;4DAWmC,CAAC;AAE7D,MAAM,kBAAkB,GAAG;;;;;;;;;;8NAUmM,CAAC;AAE/N,MAAM,iBAAiB,GAAG;;;;;;;;;;4JAUkI,CAAC;AAE7J,MAAM,aAAa,GAAG;;;;;;;;2HAQqG,CAAC;AAE5H,MAAM,iBAAiB,GAAG;;;;;;;;;;gHAUsF,CAAC;AAEjH,MAAM,aAAa,GAAG;;;;;;;;;;;;gEAY0C,CAAC;AAEjE,MAAM,kBAAkB,GAAG;;;;;;;;;;sHAU2F,CAAC;AAEvH;;uCAEuC;AAC1B,QAAA,cAAc,GAA+B;IACxD,EAAE,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,uBAAuB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE;IACxG,EAAE,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,6BAA6B,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,EAAE,aAAa,EAAE;IACrH,EAAE,GAAG,EAAE,YAAY,EAAE,IAAI,EAAE,oBAAoB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,UAAU,EAAE;IACjG,EAAE,GAAG,EAAE,sBAAsB,EAAE,IAAI,EAAE,uBAAuB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,oBAAoB,EAAE;IACrH,EAAE,GAAG,EAAE,kBAAkB,EAAE,IAAI,EAAE,kBAAkB,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,gBAAgB,EAAE;IACzG,EAAE,GAAG,EAAE,oBAAoB,EAAE,IAAI,EAAE,oBAAoB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,kBAAkB,EAAE;IACjH,EAAE,GAAG,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE;IAC9G,EAAE,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,8BAA8B,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE;IAC9G,EAAE,GAAG,EAAE,mBAAmB,EAAE,IAAI,EAAE,mBAAmB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,iBAAiB,EAAE;IAC3G,EAAE,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,eAAe,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE;IAChG,EAAE,GAAG,EAAE,oBAAoB,EAAE,IAAI,EAAE,oBAAoB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,EAAE,kBAAkB,EAAE;CAClH,CAAC;AAEF;;6DAE6D;AAChD,QAAA,mBAAmB,GAAsB,sBAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC"}

package/payload/platform/lib/routine-templates/dist/seed-cli.d.ts

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

package/payload/platform/lib/routine-templates/dist/seed-cli.d.ts.map

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

package/payload/platform/lib/routine-templates/dist/seed-cli.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Task 2130 — the install/upgrade entry point for the routine-roster seed.
+ *
+ * `platform/scripts/seed-neo4j.sh` is bash driving cypher-shell and cannot
+ * import the roster, so it invokes this instead. Everything about the seed —
+ * the MERGE, the classification, the whole `[routine-seed]` lifecycle — lives
+ * in `index.ts` and is shared verbatim with the sub-account path in the admin
+ * plugin. This file is only the process boundary: read the environment,
+ * connect, call the seed, decide the exit code.
+ *
+ * This runs on every install AND every upgrade, which is what carries the
+ * roster to the existing fleet rather than to new installs alone.
+ *
+ *   NEO4J_URI=… NEO4J_PASSWORD=… ROUTINE_SEED_ACCOUNT_ID=… node dist/seed-cli.js
+ *
+ * Exit codes:
+ *   0  the roster is present and complete (`expected === actual`)
+ *   1  a required variable is missing, Neo4j refused, or the post-condition
+ *      read came back short
+ */
+const neo4j_driver_1 = __importDefault(require("neo4j-driver"));
+const index_js_1 = require("./index.js");
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value || value.trim() === "") {
+        process.stderr.write(`[routine-seed] op=abort reason=missing-env var=${name}\n`);
+        process.exit(1);
+    }
+    return value;
+}
+async function main() {
+    const uri = requireEnv("NEO4J_URI");
+    const password = requireEnv("NEO4J_PASSWORD");
+    const accountId = requireEnv("ROUTINE_SEED_ACCOUNT_ID");
+    const user = process.env.NEO4J_USER ?? "neo4j";
+    const driver = neo4j_driver_1.default.driver(uri, neo4j_driver_1.default.auth.basic(user, password));
+    const session = driver.session();
+    try {
+        const report = await (0, index_js_1.seedRoutineRoster)({ session, accountId });
+        // The read-back is the gate, not the fact that the statements ran. A seed
+        // that issued ten MERGEs and left nine rows in the graph has failed, and
+        // the install must say so here rather than leave a short roster to be
+        // noticed later by the heartbeat's op=roster drift check.
+        if (report.verify.actual < report.verify.expected) {
+            process.stderr.write(`[routine-seed] op=abort acct=${(0, index_js_1.acctTag)(accountId)} reason=short-roster ` +
+                `expected=${report.verify.expected} actual=${report.verify.actual}\n`);
+            process.exitCode = 1;
+        }
+    }
+    finally {
+        await session.close();
+        await driver.close();
+    }
+}
+main().catch((err) => {
+    process.stderr.write(`[routine-seed] op=abort reason=error detail=${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=seed-cli.js.map

package/payload/platform/lib/routine-templates/dist/seed-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-cli.js","sourceRoot":"","sources":["../src/seed-cli.ts"],"names":[],"mappings":";;;;;AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gEAAiC;AACjC,yCAAwD;AAExD,SAAS,UAAU,CAAC,IAAY;IAC9B,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QAClC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,kDAAkD,IAAI,IAAI,CAAC,CAAC;QACjF,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,MAAM,GAAG,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC;IACpC,MAAM,QAAQ,GAAG,UAAU,CAAC,gBAAgB,CAAC,CAAC;IAC9C,MAAM,SAAS,GAAG,UAAU,CAAC,yBAAyB,CAAC,CAAC;IACxD,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,OAAO,CAAC;IAE/C,MAAM,MAAM,GAAG,sBAAK,CAAC,MAAM,CAAC,GAAG,EAAE,sBAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;IACnE,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;IACjC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,IAAA,4BAAiB,EAAC,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;QAC/D,0EAA0E;QAC1E,yEAAyE;QACzE,sEAAsE;QACtE,0DAA0D;QAC1D,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAClD,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,gCAAgC,IAAA,kBAAO,EAAC,SAAS,CAAC,uBAAuB;gBACvE,YAAY,MAAM,CAAC,MAAM,CAAC,QAAQ,WAAW,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,CACxE,CAAC;YACF,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;YAAS,CAAC;QACT,MAAM,OAAO,CAAC,KAAK,EAAE,CAAC;QACtB,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;AACH,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,+CAA+C,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CACpG,CAAC;IACF,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/payload/platform/lib/routine-templates/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "@maxy/routine-templates",
+  "private": true,
+  "type": "commonjs",
+  "main": "dist/index.js"
+}

package/payload/platform/lib/routine-templates/src/__tests__/roster.test.ts

@@ -0,0 +1,170 @@
+/**
+ * Task 2130 — the roster's shipping invariants.
+ *
+ * These assert the properties that make the roster shippable at all, so a later
+ * edit that breaks one fails here rather than on a customer's install. Two of
+ * them (the tool-name check and the private-shape check) exist because the
+ * corresponding failure is silent: a prompt naming a tool no install serves,
+ * or carrying a real mailbox, still parses, still stores, still dispatches.
+ */
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { ROUTINE_ROSTER, ROUTINE_ROSTER_KEYS, ROUTINE_TEMPLATE_VERSION } from "../roster.js";
+
+/** Every canonical maxy tool name, read from the generated registry rather than
+ *  re-listed here. A list re-typed in this file would drift from the registry,
+ *  which is the exact failure it would claim to prevent. */
+const CANONICAL_TOOL_NAMES: ReadonlySet<string> = (() => {
+  // vitest runs with cwd at this lib's root (where vitest.config.ts lives).
+  const generated = resolve(
+    process.cwd(),
+    "../../services/claude-session-manager/src/canonical-tool-names.generated.ts",
+  );
+  const raw = readFileSync(generated, "utf-8");
+  const names = new Set<string>();
+  for (const m of raw.matchAll(/mcp__plugin_[a-z0-9-]+_[a-z0-9-]+__([a-z0-9-]+)/g)) {
+    names.add(m[1]);
+  }
+  return names;
+})();
+
+/** Bare kebab-case identifiers a prompt might be citing as a tool. Deliberately
+ *  greedy: it over-collects ordinary hyphenated English, which the assertion
+ *  below then filters by asking whether the token looks like a tool name at all
+ *  (a known plugin prefix). Over-collecting is safe; under-collecting would let
+ *  an invented tool through. */
+function citedToolCandidates(prompt: string): string[] {
+  const prefixes = [
+    "email-",
+    "outlook-",
+    "google-",
+    "schedule-",
+    "work-",
+    "contact-",
+    "connector-",
+    "memory-",
+    "quickbooks-",
+    "ledger-",
+    "whatsapp-",
+    "telegram-",
+    "capabilities-",
+    "graph-",
+  ];
+  const out = new Set<string>();
+  for (const m of prompt.matchAll(/\b[a-z][a-z0-9]*(?:-[a-z0-9]+)+\b/g)) {
+    const token = m[0];
+    if (prefixes.some((p) => token.startsWith(p))) out.add(token);
+  }
+  return [...out];
+}
+
+describe("routine roster shape", () => {
+  it("ships exactly eleven routines", () => {
+    expect(ROUTINE_ROSTER).toHaveLength(11);
+  });
+
+  it("has the eleven keys the task and the drift check agree on", () => {
+    expect([...ROUTINE_ROSTER_KEYS].sort()).toEqual(
+      [
+        "appointment-reminder",
+        "calendar-reconcile",
+        "channel-link-check",
+        "commitment-chase",
+        "contact-reconcile",
+        "crm-reconcile",
+        "end-of-day",
+        "finance-reconcile",
+        "inbound-check",
+        "start-of-day",
+        "weekly-digest",
+      ].sort(),
+    );
+  });
+
+  it("keys are unique — a duplicate would collapse two rows onto one MERGE key", () => {
+    expect(new Set(ROUTINE_ROSTER_KEYS).size).toBe(ROUTINE_ROSTER.length);
+  });
+
+  it("names are unique and non-empty", () => {
+    const names = ROUTINE_ROSTER.map((r) => r.name);
+    expect(names.every((n) => n.trim().length > 0)).toBe(true);
+    expect(new Set(names).size).toBe(names.length);
+  });
+
+  it("every recurrence is a five-field cron expression", () => {
+    for (const r of ROUTINE_ROSTER) {
+      expect(r.recurrence.trim().split(/\s+/), `${r.key} recurrence`).toHaveLength(5);
+    }
+  });
+
+  it("the template version is a positive integer", () => {
+    expect(Number.isInteger(ROUTINE_TEMPLATE_VERSION)).toBe(true);
+    expect(ROUTINE_TEMPLATE_VERSION).toBeGreaterThan(0);
+  });
+});
+
+describe("routine prompts resolve their own surfaces", () => {
+  it("every prompt opens on capabilities-here", () => {
+    for (const r of ROUTINE_ROSTER) {
+      expect(r.prompt, `${r.key} must call capabilities-here`).toContain("capabilities-here");
+    }
+  });
+
+  it("every prompt states the silent-exit condition", () => {
+    for (const r of ROUTINE_ROSTER) {
+      expect(r.prompt, `${r.key} must end silently when its surface is absent`).toContain(
+        "end the turn without replying",
+      );
+    }
+  });
+
+  it("cites no tool that is absent from the canonical registry", () => {
+    const unknown: string[] = [];
+    let checked = 0;
+    for (const r of ROUTINE_ROSTER) {
+      for (const candidate of citedToolCandidates(r.prompt)) {
+        checked++;
+        if (!CANONICAL_TOOL_NAMES.has(candidate)) unknown.push(`${r.key}: ${candidate}`);
+      }
+    }
+    // A check that examined nothing would pass while the roster cited invented
+    // tools, which is the whole failure. Assert it actually reached the prompts
+    // and that the registry it compares against is populated.
+    expect(CANONICAL_TOOL_NAMES.size).toBeGreaterThan(50);
+    expect(checked).toBeGreaterThanOrEqual(ROUTINE_ROSTER.length);
+    expect(unknown).toEqual([]);
+  });
+});
+
+describe("routine prompts are generic", () => {
+  // The same classes scripts/check-routine-templates-generic.sh enforces at
+  // commit and publish time. Duplicated here so a failure is caught in the unit
+  // run too, where the message points at the routine rather than at a line
+  // number in a corpus scan.
+  const SHAPES: ReadonlyArray<{ label: string; re: RegExp }> = [
+    { label: "email address", re: /[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}/i },
+    { label: "E.164 number", re: /\+[0-9]{10,15}\b/ },
+    { label: "hostname", re: /\b[a-z0-9-]+\.(com|co\.uk|net|org|io|dev|chat|app|ai|pages\.dev)\b/i },
+    { label: "absolute developer path", re: /(\/Users\/[a-z]|\/home\/[a-z])/i },
+  ];
+
+  it("carries no email address, phone number, hostname or developer path", () => {
+    const hits: string[] = [];
+    for (const r of ROUTINE_ROSTER) {
+      for (const shape of SHAPES) {
+        const m = r.prompt.match(shape.re);
+        if (m) hits.push(`${r.key}: ${shape.label} "${m[0]}"`);
+      }
+    }
+    expect(hits).toEqual([]);
+  });
+
+  it("names no vertical as the only vertical", () => {
+    // A prompt that assumes an estate agency is not shippable to a web studio.
+    // These are the words the four live laptop routines used.
+    const verticalTells = /\b(property|listing|viewing|valuation|tenancy|landlord|vendor)\b/i;
+    const hits = ROUTINE_ROSTER.filter((r) => verticalTells.test(r.prompt)).map((r) => r.key);
+    expect(hits).toEqual([]);
+  });
+});