npm - @rubytech/taskmaster - Versions diffs - 1.13.3 → 1.14.2 - Mend

@rubytech/taskmaster 1.13.3 → 1.14.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (41) hide show

package/dist/control-ui/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <title>Taskmaster Control</title>
     <meta name="color-scheme" content="dark light" />
     <link rel="icon" type="image/png" href="./favicon.png" />
-    <script type="module" crossorigin src="./assets/index-BWqMMgRV.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-B8I8lMfz.css">
+    <script type="module" crossorigin src="./assets/index-B3nkSwMP.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-l54GcTyj.css">
   </head>
   <body>
     <taskmaster-app></taskmaster-app>

package/dist/daemon/service-port.js ADDED Viewed

@@ -0,0 +1,109 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { resolveLaunchAgentPlistPath } from "./launchd.js";
+import { resolveSystemdUserUnitPath } from "./systemd.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Update the gateway service unit (systemd or launchd) to use a new port.
+ *
+ * Replaces `--port <N>` in the ExecStart / ProgramArguments and
+ * `TASKMASTER_GATEWAY_PORT=<N>` in the service environment using targeted
+ * string replacement. This preserves all other directives (ExecStartPre,
+ * StartLimitBurst, watchdog paths, etc.) that are not round-tripped by the
+ * parse helpers.
+ *
+ * Returns `{ updated: false }` when:
+ * - The process is not supervised (no unit file found).
+ * - The unit has no `--port` argument (the in-process SIGUSR1 restart already
+ *   handles port changes in that case).
+ *
+ * On Linux: callers should schedule `process.exit(0)` so systemd
+ * (Restart=always) restarts the gateway with the updated ExecStart.
+ *
+ * On macOS: this function spawns a detached shell that calls
+ * `launchctl bootout` (which sends SIGTERM to the running process) and then
+ * `launchctl bootstrap` (which reloads the plist and starts the service via
+ * RunAtLoad=true). The caller does NOT need to call process.exit() — the
+ * bootout handles termination.
+ */
+export async function tryUpdateServiceUnitPort(newPort) {
+    const platform = process.platform;
+    if (platform === "linux") {
+        return updateSystemdPort(newPort);
+    }
+    if (platform === "darwin") {
+        return updateLaunchdPort(newPort);
+    }
+    return { updated: false, reason: `unsupported platform: ${platform}` };
+}
+async function updateSystemdPort(newPort) {
+    const unitPath = resolveSystemdUserUnitPath(process.env);
+    let content;
+    try {
+        content = await fs.readFile(unitPath, "utf8");
+    }
+    catch {
+        return { updated: false, reason: "no systemd unit file" };
+    }
+    // If --port is not baked into ExecStart, the in-process SIGUSR1 restart
+    // already re-reads the config port — no unit update needed.
+    if (!/\s--port\s+\d+/.test(content)) {
+        return { updated: false, reason: "no --port in ExecStart" };
+    }
+    const updated = content
+        .replace(/(\s--port\s+)\d+/g, `$1${newPort}`)
+        .replace(/TASKMASTER_GATEWAY_PORT=\d+/g, `TASKMASTER_GATEWAY_PORT=${newPort}`);
+    await fs.writeFile(unitPath, updated, "utf8");
+    try {
+        await execFileAsync("systemctl", ["--user", "daemon-reload"], { encoding: "utf8" });
+    }
+    catch {
+        // Non-fatal — the unit file is updated on disk; daemon-reload failure
+        // means the in-memory definition is stale but the next restart will pick up
+        // the correct file regardless.
+    }
+    return { updated: true, platform: "linux" };
+}
+async function updateLaunchdPort(newPort) {
+    const env = process.env;
+    const plistPath = resolveLaunchAgentPlistPath(env);
+    let content;
+    try {
+        content = await fs.readFile(plistPath, "utf8");
+    }
+    catch {
+        return { updated: false, reason: "no launchd plist" };
+    }
+    // If --port is not in ProgramArguments, the in-process restart already works.
+    if (!/<string>--port<\/string>/.test(content)) {
+        return { updated: false, reason: "no --port in ProgramArguments" };
+    }
+    const updated = content
+        // Replace --port value in ProgramArguments
+        .replace(/(<string>--port<\/string>\s*)<string>\d+<\/string>/, `$1<string>${newPort}</string>`)
+        // Replace TASKMASTER_GATEWAY_PORT value in EnvironmentVariables
+        .replace(/(<key>TASKMASTER_GATEWAY_PORT<\/key>\s*)<string>\d+<\/string>/, `$1<string>${newPort}</string>`);
+    await fs.writeFile(plistPath, updated, "utf8");
+    // Spawn a detached shell that outlives our process:
+    //   1. sleep 2  — give the gateway time to respond to the UI before being killed
+    //   2. bootout  — removes the service from launchd and sends SIGTERM to us
+    //   3. sleep 3  — wait for our process to exit cleanly
+    //   4. bootstrap — reloads the updated plist and auto-starts the service (RunAtLoad=true)
+    const uid = typeof process.getuid === "function" ? process.getuid() : null;
+    const domain = uid !== null ? `gui/${uid}` : "gui/501";
+    const label = env.TASKMASTER_LAUNCHD_LABEL ?? "bot.taskmaster.gateway";
+    const shellCmd = [
+        "sleep 2",
+        `launchctl bootout '${domain}/${label}'`,
+        "sleep 3",
+        `launchctl bootstrap '${domain}' '${plistPath}'`,
+    ].join(" && ");
+    const child = spawn("sh", ["-c", shellCmd], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    return { updated: true, platform: "darwin" };
+}

package/dist/gateway/server-methods/config.js CHANGED Viewed

@@ -5,6 +5,7 @@ import { applyMergePatch } from "../../config/merge-patch.js";
 import { buildConfigSchema } from "../../config/schema.js";
 import { scheduleGatewaySigusr1Restart } from "../../infra/restart.js";
 import { formatDoctorNonInteractiveHint, writeRestartSentinel, } from "../../infra/restart-sentinel.js";
+import { tryUpdateServiceUnitPort } from "../../daemon/service-port.js";
 import { listChannelPlugins } from "../../channels/plugins/index.js";
 import { loadTaskmasterPlugins } from "../../plugins/loader.js";
 import { ErrorCodes, errorShape, formatValidationErrors, validateConfigApplyParams, validateConfigGetParams, validateConfigPatchParams, validateConfigSchemaParams, validateConfigSetParams, } from "../protocol/index.js";
@@ -165,6 +166,49 @@ export const configHandlers = {
         // instead of killing the process with SIGUSR1. Use for changes that the
         // dynamic reload system handles (channel config, hooks, cron, etc.).
         const skipRestart = params.skipRestart === true;
+        // Port change: the --port arg and TASKMASTER_GATEWAY_PORT env var are baked
+        // into the service unit at daemon-install time. A plain SIGUSR1 in-process
+        // restart would reuse the original startup port, so we must update the unit
+        // file and let the supervisor restart the process with the new args instead.
+        if (!skipRestart) {
+            const newGatewayPort = validated.config.gateway?.port;
+            const oldGatewayPort = snapshot.config.gateway?.port;
+            if (typeof newGatewayPort === "number" && newGatewayPort !== oldGatewayPort) {
+                const portUpdate = await tryUpdateServiceUnitPort(newGatewayPort);
+                if (portUpdate.updated) {
+                    const effectiveDelayMs = restartDelayMs ?? 2000;
+                    const sentinelPayload = {
+                        kind: "config-apply",
+                        status: "ok",
+                        ts: Date.now(),
+                        sessionKey,
+                        message: note ?? null,
+                        doctorHint: formatDoctorNonInteractiveHint(),
+                        stats: { mode: "config.patch", root: CONFIG_PATH_TASKMASTER },
+                    };
+                    let portSentinelPath = null;
+                    try {
+                        portSentinelPath = await writeRestartSentinel(sentinelPayload);
+                    }
+                    catch {
+                        portSentinelPath = null;
+                    }
+                    respond(true, {
+                        ok: true,
+                        path: CONFIG_PATH_TASKMASTER,
+                        config: validated.config,
+                        restart: { ok: true },
+                        sentinel: portSentinelPath ? { path: portSentinelPath } : null,
+                    }, undefined);
+                    // On Linux, exit so systemd (Restart=always) restarts with the updated unit.
+                    // On macOS, the detached launchctl shell handles termination via bootout.
+                    if (portUpdate.platform === "linux") {
+                        setTimeout(() => process.exit(0), effectiveDelayMs);
+                    }
+                    return;
+                }
+            }
+        }
         let restart = null;
         let sentinelPath = null;
         if (!skipRestart) {

package/dist/infra/update-global.js CHANGED Viewed

@@ -77,7 +77,10 @@ export async function detectGlobalInstallManagerByPresence(runCommand, timeoutMs
     return null;
 }
 export function globalInstallArgs(manager, spec, needsSudo = false) {
-    const prefix = needsSudo ? ["sudo"] : [];
+    // Use -n (non-interactive) so sudo fails immediately with exit code 1 when a
+    // password is required, rather than blocking indefinitely waiting for TTY input.
+    // On systems with NOPASSWD configured (e.g. Pi deployments) this is a no-op.
+    const prefix = needsSudo ? ["sudo", "-n"] : [];
     if (manager === "pnpm")
         return [...prefix, "pnpm", "add", "-g", spec];
     if (manager === "bun")

package/dist/infra/update-runner.js CHANGED Viewed

@@ -439,8 +439,11 @@ export async function runGatewayUpdate(opts = {}) {
     const beforeVersion = await readPackageVersion(pkgRoot);
     const globalManager = await detectGlobalInstallManagerForRoot(runCommand, pkgRoot, timeoutMs);
     if (globalManager) {
-        // Global npm installs on Linux/macOS typically need sudo unless running as root
-        // or using a user-prefix setup (nvm, volta, etc.)
+        // Use sudo when the install directory is not user-writable (e.g. system npm
+        // roots like /usr/lib/node_modules). sudo is invoked with -n (non-interactive)
+        // so it fails immediately with exit code 1 when a password is required instead
+        // of blocking forever waiting for TTY input. On systems with NOPASSWD configured
+        // (typical Pi deployments) the -n flag is a no-op and the install proceeds normally.
         let needsSudo = false;
         if (os.platform() !== "win32" && process.getuid?.() !== 0) {
             try {
@@ -451,10 +454,11 @@ export async function runGatewayUpdate(opts = {}) {
             }
         }
         const spec = `@rubytech/taskmaster@${normalizeTag(opts.tag)}`;
+        const installArgv = globalInstallArgs(globalManager, spec, needsSudo);
         const updateStep = await runStep({
             runCommand,
-            name: "global update",
-            argv: globalInstallArgs(globalManager, spec, needsSudo),
+            name: installArgv.join(" "),
+            argv: installArgv,
             cwd: pkgRoot,
             timeoutMs,
             env: { PATH: augmentedPath },

package/dist/macos/gateway-daemon.js CHANGED Viewed

@@ -29,7 +29,7 @@ async function main() {
         const Long = mod.default ?? mod;
         globalThis.Long = Long;
     }
-    const [{ loadConfig }, { startGatewayServer }, { setGatewayWsLogStyle }, { setVerbose }, { acquireGatewayLock, GatewayLockError }, { consumeGatewaySigusr1RestartAuthorization, isGatewaySigusr1RestartExternallyAllowed }, { defaultRuntime }, { enableConsoleCapture, setConsoleTimestampPrefix },] = await Promise.all([
+    const [{ loadConfig, resolveGatewayPort }, { startGatewayServer }, { setGatewayWsLogStyle }, { setVerbose }, { acquireGatewayLock, GatewayLockError }, { consumeGatewaySigusr1RestartAuthorization, isGatewaySigusr1RestartExternallyAllowed }, { defaultRuntime }, { enableConsoleCapture, setConsoleTimestampPrefix },] = await Promise.all([
         import("../config/config.js"),
         import("../gateway/server.js"),
         import("../gateway/ws-logging.js"),
@@ -46,13 +46,31 @@ async function main() {
     const wsLogStyle = wsLogRaw === "compact" ? "compact" : wsLogRaw === "full" ? "full" : "auto";
     setGatewayWsLogStyle(wsLogStyle);
     const cfg = loadConfig();
-    const portRaw = argValue(args, "--port") ??
-        process.env.TASKMASTER_GATEWAY_PORT ??
-        (typeof cfg.gateway?.port === "number" ? String(cfg.gateway.port) : "") ??
-        "18789";
-    const port = Number.parseInt(portRaw, 10);
+    // Explicit --port arg: fixed for lifetime of process.
+    const portArgRaw = argValue(args, "--port");
+    const portArgOverride = portArgRaw !== undefined ? Number.parseInt(portArgRaw, 10) : null;
+    if (portArgRaw !== undefined &&
+        (portArgOverride === null || Number.isNaN(portArgOverride) || portArgOverride <= 0)) {
+        defaultRuntime.error(`Invalid --port (${portArgRaw})`);
+        process.exit(1);
+    }
+    // When no explicit --port is given, re-read on each restart so UI port changes
+    // take effect in-process. Config port is preferred over TASKMASTER_GATEWAY_PORT
+    // because the env var is set at daemon-install time and doesn't update when the
+    // user edits the port via the UI. Falls back to env var / default when the
+    // config key is absent.
+    const resolveStartPort = () => {
+        if (portArgOverride !== null)
+            return portArgOverride;
+        const currentCfg = loadConfig();
+        const cfgPort = currentCfg.gateway?.port;
+        return typeof cfgPort === "number" && Number.isFinite(cfgPort) && cfgPort > 0
+            ? cfgPort
+            : resolveGatewayPort(currentCfg);
+    };
+    const port = resolveStartPort();
     if (Number.isNaN(port) || port <= 0) {
-        defaultRuntime.error(`Invalid --port (${portRaw})`);
+        defaultRuntime.error(`Invalid port (${port})`);
         process.exit(1);
     }
     const bindRaw = argValue(args, "--bind") ?? process.env.TASKMASTER_GATEWAY_BIND ?? cfg.gateway?.bind ?? "lan";
@@ -152,7 +170,7 @@ async function main() {
         // eslint-disable-next-line no-constant-condition
         while (true) {
             try {
-                server = await startGatewayServer(port, { bind });
+                server = await startGatewayServer(resolveStartPort(), { bind });
             }
             catch (err) {
                 cleanupSignals();

package/dist/memory/manager.js CHANGED Viewed

@@ -83,6 +83,17 @@ function expandPathTemplate(pattern, ctx) {
 function normalizePhoneInMemoryPath(relPath) {
     return relPath.replace(/^(memory\/users\/)(\d)/i, "$1+$2");
 }
+/**
+ * Ensure group IDs in memory/groups/ paths include the canonical @g.us suffix.
+ * AI agents sometimes omit the suffix when constructing paths
+ * (e.g. "memory/groups/120363423828326592/members/..." instead of
+ * "memory/groups/120363423828326592@g.us/members/...").
+ * The session peer and filesystem convention always use the full JID with @g.us.
+ * Without this, scope patterns like memory/groups/{peer}/** won't match the path.
+ */
+function normalizeGroupIdInMemoryPath(relPath) {
+    return relPath.replace(/^(memory\/groups\/)(\d{15,})(?!\S*@)(\/)/i, "$1$2@g.us$3");
+}
 /**
  * Simple glob pattern matcher supporting * and **.
  * - * matches any characters except /
@@ -527,7 +538,7 @@ export class MemoryIndexManager {
         return this.syncing;
     }
     async readFile(params) {
-        const relPath = normalizePhoneInMemoryPath(normalizeRelPath(params.relPath));
+        const relPath = normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(normalizeRelPath(params.relPath)));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error(relPath
                 ? `invalid path "${relPath}" — must start with "memory/" (e.g. "memory/admin/file.md")`
@@ -567,7 +578,7 @@ export class MemoryIndexManager {
      * matching the session's scope configuration.
      */
     async writeFile(params) {
-        const relPath = normalizePhoneInMemoryPath(normalizeRelPath(params.relPath));
+        const relPath = normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(normalizeRelPath(params.relPath)));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error(relPath
                 ? `invalid path "${relPath}" — must start with "memory/" (e.g. "memory/admin/file.md")`
@@ -615,7 +626,7 @@ export class MemoryIndexManager {
         let relPath;
         if (params.destFolder) {
             // Explicit folder — use as-is (scope checking enforces access)
-            relPath = normalizePhoneInMemoryPath(`${params.destFolder}/${params.destFilename}`);
+            relPath = normalizeGroupIdInMemoryPath(normalizePhoneInMemoryPath(`${params.destFolder}/${params.destFilename}`));
         }
         else {
             // Default: memory/users/{peer}/media/{filename}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rubytech/taskmaster",
-  "version": "1.13.3",
+  "version": "1.14.2",
   "description": "AI-powered business assistant for small businesses",
   "publishConfig": {
     "access": "public"

package/skills/sales-closer/SKILL.md ADDED Viewed

@@ -0,0 +1,29 @@
+---
+name: sales-closer
+description: "Detects buying signals in customer conversations and guides the agent to close sales effectively. Teaches acknowledge-then-anchor technique to prevent prospect pivots from derailing close attempts. Reinforces business owner offers and tracks close outcomes."
+metadata: {"taskmaster":{"always":true,"emoji":"🎯","skillKey":"sales-closer"}}
+---
+# Sales Closer
+You are always watching for buying signals in customer conversations. When a prospect shows intent, your priority shifts from informing to closing.
+## Three Rules
+1. **Detect buying signals** — Enthusiasm, future-tense commitment, pricing/setup/next-step questions, returning after a gap, sharing detailed business info unprompted. When you detect these, enter closing mode.
+2. **Acknowledge-then-anchor** — When a prospect asks a question mid-close, give a brief answer, then immediately re-anchor to the commitment ask. Never let a question fully derail the close. The sequence is always: brief answer → re-anchor. Not: full answer → trailing close.
+3. **Reinforce the owner's offers** — When the business owner presents options in the conversation, actively frame and reinforce those options for the prospect. Never let an owner's offer go un-anchored.
+## What Closing Is Not
+Never pressure, manipulate, or create false urgency. Never repeat the same close more than twice consecutively. Never close over genuine unresolved concerns — address them first. Never commit to pricing or terms the business owner has not authorised.
+## References
+Load the relevant reference when the situation requires it:
+- **Closing methodology** → `references/closing-framework.md` — buying signals, closing techniques, the golden rule, when to close vs when to wait
+- **Objections & pivots** → `references/objection-handling.md` — distinguishing pivots from objections, acknowledge-then-anchor patterns, common objection types
+- **Tracking & follow-up** → `references/close-tracking.md` — persisting close attempts to memory, CRM updates, follow-up scheduling, escalation after stalled closes

package/skills/sales-closer/references/close-tracking.md ADDED Viewed

@@ -0,0 +1,86 @@
+# Close Tracking
+## Why Track
+Closing is iterative. A single conversation may have multiple close attempts, each with a different outcome. Tracking close attempts in memory enables:
+- Pattern recognition: which techniques work for this prospect?
+- Follow-up discipline: when did we agree to check back?
+- Escalation context: if handing off to the owner, what has already been tried?
+- Pipeline accuracy: is this prospect in "enquiry" or genuinely moving toward "booked"?
+## Where to Write
+Close tracking data lives in the prospect's memory profile. The path depends on the session type:
+- **DM sessions:** `memory/users/{phone}/profile.md` — append to the prospect's user profile
+- **Group sessions:** `memory/groups/{groupId}/members/{phone}.md` — append to the prospect's group member profile
+The public agent can only write to user-scoped memory (`memory/users/{peer}/**`) and group-scoped memory (`memory/groups/{peer}/**`) for the current session's peer. In a group conversation, write to the group member file — not to the user's DM profile.
+## What to Record
+After each close attempt in a customer conversation, write a brief entry to the prospect's memory profile:
+```
+## Sales Close Log
+### [Date] — [Close technique used]
+- **Ask:** [What was asked — e.g. "Shall we get you set up with a trial?"]
+- **Outcome:** [committed / pivoted / objected / deferred]
+- **Detail:** [What happened — e.g. "Prospect asked about CRM integration, acknowledged-then-anchored, prospect said they'd think about it"]
+- **Follow-up:** [Next action — e.g. "Check back Thursday" or "None — committed"]
+```
+Keep entries concise. The purpose is context for the next interaction, not a transcript.
+## When to Update the CRM Contact Record
+The CRM pipeline (managed by the business-assistant skill via `contact_update`) should be updated at these moments:
+| Close outcome | CRM action |
+|--------------|------------|
+| Prospect commits to a purchase/subscription | Update status to `booked` (or the appropriate stage) |
+| Prospect commits to a trial | Update status to `booked`, add note: "Trial started [date]" |
+| Quote accepted | Update status from `quoted` to `booked` |
+| Prospect explicitly declines | Update status to `archived`, add note with reason |
+| Prospect defers | Keep current status, add `lastContact` date and follow-up note |
+Do not update the CRM status on pivots or mid-conversation objections — only on definitive outcomes.
+## Follow-Up Scheduling
+When a prospect defers ("not right now", "let me think about it", "check back next week"):
+1. Agree on a specific follow-up date — ask: "When would be good to check back?"
+2. If no date given, default to 3 business days
+3. Write the follow-up date to memory: `Follow-up: [date] — [context]`
+4. When the follow-up date arrives and the agent receives a cron trigger or the prospect messages again, use the **Return Close** technique — they were interested, just needed time
+## Escalation Rules
+Escalate to the business owner when:
+1. **Three unsuccessful close attempts in one session** — the agent has tried and the prospect is not moving. Summarise what was tried and hand off.
+2. **Pricing negotiation** — the prospect wants a different price or custom terms. The agent does not have authority.
+3. **Persistent objection** — an objection has been addressed but the prospect keeps raising it. The concern may need a human touch.
+4. **Prospect requests human contact** — always respect this immediately.
+When escalating, send the business owner a structured summary:
+```
+**Sales escalation — [Prospect name]**
+What they need: [1-2 sentences]
+Where we are: [Current pipeline stage]
+What was tried: [Close techniques used and outcomes]
+What's blocking: [The specific objection or stall]
+Recommended next step: [Your suggestion for the owner]
+```
+## Integration with Quote Follow-Ups
+The business-assistant skill's quoting reference already has follow-up nudges (3-day nudge, 7-day escalation). When a quote follow-up is triggered, apply closing intent — do not send a passive "just checking in" message. Instead:
+- **3-day nudge:** Use the Summary Close — recap the quote, restate value, ask directly: "Shall I book this in?"
+- **7-day escalation:** Escalate to the business owner with full context, not just "no response." Include: what was quoted, what follow-up has been sent, and a recommendation (chase, re-quote at different price, or close as lost).

package/skills/sales-closer/references/closing-framework.md ADDED Viewed

@@ -0,0 +1,112 @@
+# Closing Framework
+## Buying Signals
+A buying signal is anything the prospect says or does that indicates they are mentally moving toward commitment. Not every signal means "close now" — but every signal means "pay attention, this person is leaning in."
+**Verbal signals:**
+- Enthusiasm: "love it", "sounds great", "exactly what I need", "brilliant"
+- Future-tense commitment: "when we set this up", "I'd want to", "once I'm onboarded"
+- Asking about pricing, packages, timelines, or next steps
+- Asking about integration with their existing tools — they are mentally placing the product in their workflow
+- Sharing detailed business information unprompted — they are investing in the relationship
+- Asking operational questions: "who would I contact for support?", "how does billing work?"
+**Behavioural signals:**
+- Returning to a conversation after a gap — they have been thinking about it; they have already decided
+- Responding quickly to messages — engagement indicates interest
+- Introducing the product to colleagues or partners — social commitment
+- Completing onboarding steps before being asked
+**Critical insight:** When a prospect returns after a gap (hours or days), they are almost certainly ready. Do not re-sell. Confirm and close: "Great to have you back! Sounds like you're ready — shall we confirm [specific next step]?"
+## Closing Techniques
+These are principles, not scripts. The agent adapts the language to the conversation's tone and the business's communication style.
+### Direct Close
+Ask for the commitment directly. Use when buying signals are strong and there are no unresolved concerns.
+> "Shall I get you set up?"
+> "Ready to go ahead?"
+> "Let's get you started — shall we?"
+### Choice Close
+Present two options, both of which are a "yes." Use when the business owner has presented options, or when you need to move from "if" to "which."
+> "Would you prefer the standard subscription or the Founders Club?"
+> "Shall we start with the trial or go straight to full setup?"
+### Summary Close
+Recap what the prospect has told you — their needs, pain points, and what the product solves — then close. Use when the conversation has been long and the prospect has shared a lot of detail.
+> "So you need 24/7 coverage for enquiries, something to handle the hours Anneke isn't available, and a way to capture leads from your socials. That's exactly what we do — shall we get you set up?"
+### Next-Step Close
+Propose a specific, concrete next step rather than an abstract commitment. Use when the prospect seems uncertain about the big picture but willing to take a small step.
+> "The next step is getting your WhatsApp number configured — takes about 10 minutes. Shall we do that now?"
+> "Joel can walk you through the pricing options — shall I get him to send those over?"
+### Return Close
+When a prospect returns after a gap. They have been thinking about it — they are ready. Confirm, don't re-sell.
+> "Great to hear from you! Sounds like you're ready to move forward — shall we confirm [next step]?"
+## The Golden Rule
+**Close before answering the next question.**
+When a prospect asks a question during a close attempt, the natural instinct is to answer the question fully — then append a close as an afterthought. This is wrong. The close gets buried and ignored.
+The correct sequence:
+1. Briefly acknowledge the question (1-2 sentences max)
+2. Immediately re-anchor to the commitment ask
+3. If they still want a deeper answer, they will ask again — and now you can answer without losing the close
+**Example (from the Alex session):**
+Wrong:
+> "Loop CRM doesn't have a direct integration yet, but here are three ways we can work around it... [detailed explanation]. So, ready to give it a go?"
+Right:
+> "Good question on Loop — no direct integration yet, but we've got workarounds that work well. We can dig into the details once you're set up. So — shall we get you started?"
+The prospect who genuinely needs the CRM answer before committing will say so. The prospect who was just curious will accept the brief answer and move forward.
+## When to Close vs When to Wait
+**Close when:**
+- Buying signals are present
+- Discovery is reasonably complete (you understand their needs)
+- The business owner has presented or approved an offer
+- The prospect returns after a gap
+**Wait when:**
+- The prospect has genuine unresolved concerns (not pivots — actual objections)
+- You do not yet understand what they need (discovery incomplete)
+- The business owner has not set pricing or terms
+- The prospect has explicitly said "not now" and given a reason — respect it, set a follow-up
+**Escalate when:**
+- The prospect asks about pricing the agent is not authorised to quote
+- The close has been attempted 3 times in one session without success
+- The prospect wants to negotiate terms
+- The prospect wants to speak to a human
+## Reinforcing the Owner's Offers
+When the business owner presents an offer in the conversation (pricing, packages, special deals), the agent must:
+1. **Register the offer** — note exactly what was presented
+2. **Frame the options** — if the owner gave multiple options, present them clearly: "So you've got two options: [A] or [B]. Which sounds right for you?"
+3. **Anchor to the offer** — in subsequent messages, reference the specific offer rather than generic closing language
+4. **Never modify or add to the offer** — only reinforce what the owner actually said
+If the owner's offer goes unanswered by the prospect, circle back to it within the conversation: "Joel mentioned the Founders Club option earlier — have you had a chance to think about that?"