@rubytech/taskmaster 1.0.105 → 1.0.107

package/dist/gateway/server-methods/skills.js

@@ -1,10 +1,13 @@
-import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveAgentWorkspaceDir, resolveAgentWorkspaceRoot, resolveDefaultAgentId } from "../../agents/agent-scope.js";
 import { installSkill } from "../../agents/skills-install.js";
 import { buildWorkspaceSkillStatus } from "../../agents/skills-status.js";
-import { loadWorkspaceSkillEntries } from "../../agents/skills.js";
+import { loadWorkspaceSkillEntries, resolveBundledSkillsDir } from "../../agents/skills.js";
+import { bumpSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
 import { loadConfig, writeConfigFile } from "../../config/config.js";
 import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
-import { ErrorCodes, errorShape, formatValidationErrors, validateSkillsBinsParams, validateSkillsInstallParams, validateSkillsStatusParams, validateSkillsUpdateParams, } from "../protocol/index.js";
+import { ErrorCodes, errorShape, formatValidationErrors, validateSkillsBinsParams, validateSkillsCreateParams, validateSkillsDeleteDraftParams, validateSkillsDeleteParams, validateSkillsDraftsParams, validateSkillsInstallParams, validateSkillsReadParams, validateSkillsStatusParams, validateSkillsUpdateParams, } from "../protocol/index.js";
 function listWorkspaceDirs(cfg) {
     const dirs = new Set();
     const list = cfg.agents?.list;
@@ -45,6 +48,21 @@ function collectSkillBins(entries) {
     }
     return [...bins].sort();
 }
+function resolveWorkspaceRoot(cfg) {
+    return resolveAgentWorkspaceRoot(cfg, resolveDefaultAgentId(cfg));
+}
+function isPreloadedSkill(skillKey) {
+    const dir = resolveBundledSkillsDir();
+    if (!dir)
+        return false;
+    try {
+        return fs.existsSync(`${dir}/${skillKey}`) &&
+            fs.statSync(`${dir}/${skillKey}`).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 export const skillsHandlers = {
     "skills.status": ({ params, respond }) => {
         if (!validateSkillsStatusParams(params)) {
@@ -97,6 +115,10 @@ export const skillsHandlers = {
             return;
         }
         const p = params;
+        if (p.enabled === false && isPreloadedSkill(p.skillKey)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "preloaded skills cannot be disabled"));
+            return;
+        }
         const cfg = loadConfig();
         const skills = cfg.skills ? { ...cfg.skills } : {};
         const entries = skills.entries ? { ...skills.entries } : {};
@@ -134,4 +156,138 @@ export const skillsHandlers = {
         await writeConfigFile(nextConfig);
         respond(true, { ok: true, skillKey: p.skillKey, config: current }, undefined);
     },
+    "skills.read": ({ params, respond }) => {
+        if (!validateSkillsReadParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.read params: ${formatValidationErrors(validateSkillsReadParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const skillDir = path.join(root, "skills", p.name);
+        const skillFile = path.join(skillDir, "SKILL.md");
+        if (!fs.existsSync(skillFile)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `skill "${p.name}" not found`));
+            return;
+        }
+        const content = fs.readFileSync(skillFile, "utf-8");
+        const references = [];
+        const refsDir = path.join(skillDir, "references");
+        if (fs.existsSync(refsDir) && fs.statSync(refsDir).isDirectory()) {
+            for (const entry of fs.readdirSync(refsDir, { withFileTypes: true })) {
+                if (entry.isFile() && entry.name.endsWith(".md")) {
+                    references.push({
+                        name: entry.name,
+                        content: fs.readFileSync(path.join(refsDir, entry.name), "utf-8"),
+                    });
+                }
+            }
+            references.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        respond(true, { name: p.name, content, references }, undefined);
+    },
+    "skills.create": async ({ params, respond }) => {
+        if (!validateSkillsCreateParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.create params: ${formatValidationErrors(validateSkillsCreateParams.errors)}`));
+            return;
+        }
+        const p = params;
+        if (isPreloadedSkill(p.name)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "cannot overwrite a preloaded skill"));
+            return;
+        }
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const skillDir = path.join(root, "skills", p.name);
+        // If the skill already exists (user skill), remove it first so we get a clean replace
+        if (fs.existsSync(skillDir)) {
+            fs.rmSync(skillDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), p.skillContent, "utf-8");
+        if (p.references && p.references.length > 0) {
+            const refsDir = path.join(skillDir, "references");
+            fs.mkdirSync(refsDir, { recursive: true });
+            for (const ref of p.references) {
+                const safeName = ref.name.replace(/[^a-zA-Z0-9._-]/g, "-");
+                fs.writeFileSync(path.join(refsDir, safeName), ref.content, "utf-8");
+            }
+        }
+        bumpSkillsSnapshotVersion();
+        respond(true, { ok: true, name: p.name }, undefined);
+    },
+    "skills.delete": async ({ params, respond }) => {
+        if (!validateSkillsDeleteParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.delete params: ${formatValidationErrors(validateSkillsDeleteParams.errors)}`));
+            return;
+        }
+        const p = params;
+        if (isPreloadedSkill(p.name)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, "preloaded skills cannot be deleted"));
+            return;
+        }
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const skillDir = path.join(root, "skills", p.name);
+        if (!fs.existsSync(skillDir)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `skill "${p.name}" not found`));
+            return;
+        }
+        fs.rmSync(skillDir, { recursive: true, force: true });
+        bumpSkillsSnapshotVersion();
+        respond(true, { ok: true, name: p.name }, undefined);
+    },
+    "skills.drafts": ({ params, respond }) => {
+        if (!validateSkillsDraftsParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.drafts params: ${formatValidationErrors(validateSkillsDraftsParams.errors)}`));
+            return;
+        }
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const draftsDir = path.join(root, ".skill-drafts");
+        if (!fs.existsSync(draftsDir)) {
+            respond(true, { drafts: [] }, undefined);
+            return;
+        }
+        const drafts = [];
+        for (const entry of fs.readdirSync(draftsDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const skillFile = path.join(draftsDir, entry.name, "SKILL.md");
+            if (!fs.existsSync(skillFile))
+                continue;
+            const skillContent = fs.readFileSync(skillFile, "utf-8");
+            const references = [];
+            const refsDir = path.join(draftsDir, entry.name, "references");
+            if (fs.existsSync(refsDir) && fs.statSync(refsDir).isDirectory()) {
+                for (const ref of fs.readdirSync(refsDir, { withFileTypes: true })) {
+                    if (ref.isFile() && ref.name.endsWith(".md")) {
+                        references.push({
+                            name: ref.name,
+                            content: fs.readFileSync(path.join(refsDir, ref.name), "utf-8"),
+                        });
+                    }
+                }
+                references.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            drafts.push({ name: entry.name, skillContent, references });
+        }
+        respond(true, { drafts }, undefined);
+    },
+    "skills.deleteDraft": ({ params, respond }) => {
+        if (!validateSkillsDeleteDraftParams(params)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `invalid skills.deleteDraft params: ${formatValidationErrors(validateSkillsDeleteDraftParams.errors)}`));
+            return;
+        }
+        const p = params;
+        const cfg = loadConfig();
+        const root = resolveWorkspaceRoot(cfg);
+        const draftDir = path.join(root, ".skill-drafts", p.name);
+        if (!fs.existsSync(draftDir)) {
+            respond(false, undefined, errorShape(ErrorCodes.INVALID_REQUEST, `draft "${p.name}" not found`));
+            return;
+        }
+        fs.rmSync(draftDir, { recursive: true, force: true });
+        respond(true, { ok: true, name: p.name }, undefined);
+    },
 };

package/dist/gateway/server-methods/wifi.js

@@ -227,16 +227,6 @@ export const wifiHandlers = {
             }
             // Check for saved connection profile
             const saved = await getSavedWifiConnection();
-            // Auto-reconnect: if a saved profile with autoconnect exists but device
-            // is disconnected, nudge NetworkManager to bring the connection up.
-            // Fire-and-forget — the next status poll will reflect the result.
-            if (saved && saved.autoconnect && !deviceState.connected) {
-                runExec("nmcli", ["con", "up", saved.name], { timeoutMs: 30_000 })
-                    .then(() => disableWifiPowerSave(context.logGateway))
-                    .catch((err) => {
-                    context.logGateway.warn(`wifi auto-reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
-                });
-            }
             respond(true, {
                 available: true,
                 connected: deviceState.connected,

package/dist/gateway/server-methods-list.js

@@ -41,6 +41,11 @@ const BASE_METHODS = [
     "skills.bins",
     "skills.install",
     "skills.update",
+    "skills.read",
+    "skills.create",
+    "skills.delete",
+    "skills.drafts",
+    "skills.deleteDraft",
     "update.status",
     "update.run",
     "voicewake.get",

package/dist/gateway/server-methods.js

@@ -36,6 +36,7 @@ import { publicChatHandlers } from "./server-methods/public-chat.js";
 import { tailscaleHandlers } from "./server-methods/tailscale.js";
 import { wifiHandlers } from "./server-methods/wifi.js";
 import { workspacesHandlers } from "./server-methods/workspaces.js";
+import { brandHandlers } from "./server-methods/brand.js";
 const ADMIN_SCOPE = "operator.admin";
 const READ_SCOPE = "operator.read";
 const WRITE_SCOPE = "operator.write";
@@ -236,6 +237,7 @@ export const coreGatewayHandlers = {
     ...memoryHandlers,
     ...recordsHandlers,
     ...workspacesHandlers,
+    ...brandHandlers,
     ...publicChatHandlers,
     ...tailscaleHandlers,
     ...wifiHandlers,

package/dist/gateway/server-wifi-watchdog.js

@@ -0,0 +1,105 @@
+/**
+ * Server-side WiFi watchdog for Raspberry Pi.
+ *
+ * Runs every 30 seconds on Linux. If a saved NetworkManager WiFi profile
+ * with autoconnect=yes exists but wlan0 is disconnected, nudges NM to
+ * reconnect and disables WiFi power save.
+ *
+ * This runs in the gateway process itself — independent of any UI polling —
+ * so WiFi recovers even when no browser is connected.
+ */
+import os from "node:os";
+import { runExec } from "../process/exec.js";
+const WATCHDOG_INTERVAL_MS = 30_000;
+let timer = null;
+export function startWifiWatchdog(log) {
+    if (os.platform() !== "linux")
+        return;
+    if (timer)
+        return;
+    // Check immediately on startup, then every 30s
+    void runWifiCheck(log);
+    timer = setInterval(() => void runWifiCheck(log), WATCHDOG_INTERVAL_MS);
+}
+export function stopWifiWatchdog() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+async function runWifiCheck(log) {
+    try {
+        // Verify nmcli is available
+        try {
+            await runExec("nmcli", ["--version"], { timeoutMs: 3_000 });
+        }
+        catch {
+            return; // nmcli not installed — nothing to do
+        }
+        // Check wlan0 device state
+        const { connected } = await getWlan0State();
+        if (connected)
+            return; // All good
+        // Check for a saved WiFi profile with autoconnect enabled
+        const saved = await getSavedAutoconnectProfile();
+        if (!saved)
+            return; // No saved profile — nothing to reconnect to
+        // Saved profile exists but WiFi is down — nudge NM to reconnect
+        log.info(`wifi watchdog: reconnecting to "${saved}"…`);
+        try {
+            await runExec("nmcli", ["con", "up", saved], { timeoutMs: 30_000 });
+            log.info(`wifi watchdog: reconnected to "${saved}"`);
+            // Disable power save to prevent future drops
+            try {
+                await runExec("iw", ["dev", "wlan0", "set", "power_save", "off"], { timeoutMs: 5_000 });
+            }
+            catch {
+                // Non-critical
+            }
+        }
+        catch (err) {
+            log.warn(`wifi watchdog: reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    catch (err) {
+        log.warn(`wifi watchdog: check failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function getWlan0State() {
+    try {
+        const { stdout } = await runExec("nmcli", ["-t", "-f", "GENERAL.STATE", "dev", "show", "wlan0"], { timeoutMs: 5_000 });
+        for (const line of stdout.split("\n")) {
+            if (line.startsWith("GENERAL.STATE:")) {
+                return { connected: line.includes("100") };
+            }
+        }
+    }
+    catch {
+        // wlan0 might not exist
+    }
+    return { connected: false };
+}
+async function getSavedAutoconnectProfile() {
+    try {
+        const { stdout } = await runExec("nmcli", ["-t", "-f", "NAME,TYPE,AUTOCONNECT", "con", "show"], { timeoutMs: 5_000 });
+        for (const line of stdout.split("\n")) {
+            if (!line.trim())
+                continue;
+            const placeholder = "\x00";
+            const safe = line.replace(/\\:/g, placeholder);
+            const parts = safe.split(":");
+            if (parts.length < 3)
+                continue;
+            const name = parts[0].replace(new RegExp(placeholder, "g"), ":").trim();
+            const type = parts[1].trim();
+            const autoconnect = parts[2].trim().toLowerCase() === "yes";
+            if (type === "802-11-wireless" && autoconnect) {
+                return name;
+            }
+        }
+    }
+    catch {
+        // Non-critical
+    }
+    return null;
+}

package/dist/gateway/server.impl.js

@@ -50,6 +50,7 @@ import { startGatewaySidecars } from "./server-startup.js";
 import { logGatewayStartup } from "./server-startup-log.js";
 import { ensureWatchdogUnitOnStartup, scheduleWatchdogStabilityConfirmation, } from "./server-watchdog.js";
 import { startGatewayTailscaleExposure } from "./server-tailscale.js";
+import { startWifiWatchdog } from "./server-wifi-watchdog.js";
 import { loadGatewayTlsRuntime } from "./server/tls.js";
 import { createWizardSessionTracker } from "./server-wizard-sessions.js";
 import { attachGatewayWsHandlers } from "./server-ws-runtime.js";
@@ -421,6 +422,8 @@ export async function startGatewayServer(port = 18789, opts = {}) {
         logChannels,
         logBrowser,
     }));
+    // Start WiFi watchdog on Linux — auto-reconnects saved WiFi if connection drops
+    startWifiWatchdog(log.child("wifi"));
     // Initialize memory managers for all agents and sync indexes at gateway startup
     const logMemory = log.child("memory");
     const agentIds = listAgentIds(cfgAtStart);

package/dist/memory/manager.js

@@ -74,6 +74,15 @@ function expandPathTemplate(pattern, ctx) {
         result = result.replaceAll("{agentId}", ctx.agentId);
     return result;
 }
+/**
+ * Ensure phone numbers in memory/users/ paths include the canonical + prefix.
+ * AI agents sometimes omit the + when constructing paths (e.g. "memory/users/447734875155/...")
+ * but the session peer and filesystem convention always use + (e.g. "+447734875155").
+ * Without this, scope patterns like memory/users/{peer}/** won't match the path.
+ */
+function normalizePhoneInMemoryPath(relPath) {
+    return relPath.replace(/^(memory\/users\/)(\d)/i, "$1+$2");
+}
 /**
  * Simple glob pattern matcher supporting * and **.
  * - * matches any characters except /
@@ -517,7 +526,7 @@ export class MemoryIndexManager {
         return this.syncing;
     }
     async readFile(params) {
-        const relPath = normalizeRelPath(params.relPath);
+        const relPath = normalizePhoneInMemoryPath(normalizeRelPath(params.relPath));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error("path required");
         }
@@ -552,7 +561,7 @@ export class MemoryIndexManager {
      * matching the session's scope configuration.
      */
     async writeFile(params) {
-        const relPath = normalizeRelPath(params.relPath);
+        const relPath = normalizePhoneInMemoryPath(normalizeRelPath(params.relPath));
         if (!relPath || !isMemoryPath(relPath)) {
             throw new Error("path required (must be in memory/ directory)");
         }
@@ -598,7 +607,7 @@ export class MemoryIndexManager {
         let relPath;
         if (params.destFolder) {
             // Explicit folder — use as-is (scope checking enforces access)
-            relPath = `${params.destFolder}/${params.destFilename}`;
+            relPath = normalizePhoneInMemoryPath(`${params.destFolder}/${params.destFilename}`);
         }
         else {
             // Default: memory/users/{peer}/media/{filename}

package/package.json

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

package/skills/skill-builder/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: skill-builder
+description: "Guide the user through creating a new lean skill — collect name, description, behaviour rules, and references, then save as a draft for the user to install via the Control Panel."
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Skill Builder
+
+A deterministic walkthrough for creating new lean skills. Follow each step in order. Be conversational — one question at a time.
+
+## When to Activate
+
+The admin requests a new skill, asks to "create a skill", "add a skill", or invokes `/skill-builder`.
+
+## Before Starting
+
+Load `references/lean-pattern.md` for the template and examples. Use it throughout as your reference for correct structure.
+
+## Step 1: Understand the Purpose
+
+Ask: **"What should this skill do?"**
+
+Listen for:
+- What capability it adds (scheduling, quoting, inventory, etc.)
+- When it should activate (what triggers it)
+- What tools or data it needs (memory, web search, file access, etc.)
+
+Clarify until you can describe the skill in one sentence. This becomes the `description` in frontmatter.
+
+## Step 2: Choose a Name
+
+Propose a name based on the purpose. Names must be:
+- Lowercase
+- Hyphen-separated (e.g. `inventory-management`)
+- Short and descriptive
+
+Confirm with the user.
+
+## Step 3: Define Behaviour
+
+Ask what rules the agent should follow when using this skill:
+- **Tone and style** — formal, casual, WhatsApp-short?
+- **Activation conditions** — when exactly should the agent use this skill?
+- **Hard boundaries** — what should the agent never do?
+- **Data sources** — where does the skill's knowledge live? (memory, external API, files)
+- **Escalation** — when should it hand off to admin?
+
+Not every skill needs all of these. Only include what's relevant.
+
+## Step 4: Decide on References
+
+If the skill has detailed procedures, templates, or data formats, those belong in `references/` files — not inline in SKILL.md.
+
+Ask: **"Are there any detailed procedures, templates, or formats this skill needs?"**
+
+For each reference file:
+- Give it a descriptive filename (e.g. `event-format.md`, `quoting-rules.md`)
+- Collect the content from the user — they can dictate, paste, or describe it and you draft it
+
+If the skill is simple enough to fit in SKILL.md alone (under ~30 lines of instructions), skip references.
+
+## Step 5: Compose the Skill
+
+Using the lean pattern from `references/lean-pattern.md`, compose:
+
+1. **SKILL.md** — frontmatter (`name`, `description`) + activation conditions + behaviour rules + references index
+2. **Reference files** — one per detailed topic
+
+Show the user the complete SKILL.md content and each reference file. Ask them to review.
+
+## Step 6: Save the Draft
+
+Use your `write` tool to save the skill as a draft:
+
+1. Create `../../.skill-drafts/{name}/SKILL.md` with the composed content
+2. For each reference file: create `../../.skill-drafts/{name}/references/{filename}`
+
+The `../../` resolves from your agent directory to the workspace root. The `.skill-drafts/` folder at the workspace root is where the Control Panel looks for drafts.
+
+**Important:** Write to `.skill-drafts/`, NOT directly to `skills/`. The user installs the skill through the Control Panel.
+
+## Step 7: Direct to Control Panel
+
+Tell the user:
+
+> "Your skill draft is ready. To install it:
+> 1. Open the **Control Panel** → **Advanced** → **Skills**
+> 2. Click **Add Skill**
+> 3. Your draft will appear under 'Import from draft' — click it to load
+> 4. Review the content and click **Save Skill**
+>
+> Once saved, the skill will be available to agents on the next message."
+
+---
+
+**Remember:** Be conversational. Don't dump all questions at once. Guide through each step one at a time.

package/skills/skill-builder/references/lean-pattern.md

@@ -0,0 +1,118 @@
+# Lean SKILL.md Pattern
+
+Skills teach agents specialised capabilities. Each skill is a directory containing a `SKILL.md` file and optional `references/` subdirectory.
+
+## Directory Structure
+
+```
+skills/
+  my-skill/
+    SKILL.md              ← Main file (lean index)
+    references/
+      detailed-guide.md   ← Loaded on demand via skill_read
+      templates.md
+```
+
+## SKILL.md Template
+
+```markdown
+---
+name: my-skill
+description: "One-line summary of what this skill does — used for agent routing."
+---
+
+# My Skill
+
+Applies when [activation conditions].
+
+## When to Activate
+
+- [Trigger condition 1]
+- [Trigger condition 2]
+
+## Behaviour
+
+[Concise rules — keep this section short. Move detailed procedures to references.]
+
+## References
+
+Load `references/detailed-guide.md` for [what it covers].
+Load `references/templates.md` for [what it covers].
+```
+
+## Principles
+
+1. **SKILL.md is an index, not a manual.** Keep it under 30 lines of instructions. The agent reads it on every activation — bloated skills waste context.
+
+2. **References hold the detail.** Procedures, templates, data formats, and examples go in `references/`. The agent loads them on demand with `skill_read`.
+
+3. **Frontmatter is required.** Every SKILL.md must start with YAML frontmatter containing `name` and `description`. Missing `description` causes the skill to be silently skipped.
+
+4. **Description drives routing.** The description is injected into the agent's prompt as part of the available skills list. Make it specific enough that the agent activates the skill for the right messages.
+
+5. **Behaviour, not data.** Skills define how the agent should act. Business-specific data (pricing, customer info, hours) belongs in memory, not in the skill file. Skills are generic; memory is specific.
+
+## Optional Frontmatter Fields
+
+```yaml
+metadata: {"taskmaster":{"always":true,"emoji":"📦","primaryEnv":"MY_API_KEY"}}
+```
+
+| Field | Purpose |
+|-------|---------|
+| `always` | Always include in prompt (skip eligibility checks) |
+| `emoji` | Display emoji in the Control Panel |
+| `primaryEnv` | Env var for API key — enables the key input field in the UI |
+| `requires.bins` | Required binaries (e.g. `["curl"]`) |
+| `requires.env` | Required environment variables |
+
+Most user-created skills need only `name` and `description`.
+
+## Examples
+
+### Simple skill (no references)
+
+```markdown
+---
+name: weather
+description: "Provide weather context for scheduling and outdoor work decisions."
+---
+
+# Weather
+
+When scheduling or planning outdoor work, check weather conditions.
+
+## When to Activate
+
+- Customer asks about weather
+- Scheduling outdoor appointments
+- Weather might affect planned work
+
+## Behaviour
+
+Use the `web_search` tool to check current weather for the business location.
+Keep weather info brief — one or two sentences unless asked for detail.
+```
+
+### Lean skill with references
+
+```markdown
+---
+name: event-management
+description: "Manage anything time-bound: appointments, meetings, reminders, follow-ups."
+---
+
+# Event Management
+
+Applies when handling anything time-bound.
+
+## When to Activate
+
+- Customer requests or confirms an appointment
+- Business owner asks to schedule, reschedule, or cancel something
+- A reminder or follow-up needs to be recorded
+
+## References
+
+Load `references/events.md` for the standard event template, file naming, and calendar query instructions.
+```

package/skills/zero-to-prototype/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: zero-to-prototype
+description: "Guide business owners from a raw idea to a validated concept — customer discovery, assumption testing, value proposition, and a simple PRD. For entrepreneurs exploring new products, services, or pivots."
+metadata: {"taskmaster":{"emoji":"🚀"}}
+---
+
+# Zero to Prototype
+
+Helps business owners validate ideas before investing time and money. Covers the full journey from initial concept to a clear product requirement document.
+
+## When to Activate
+
+- Owner says they have an idea for a new product, service, or offering
+- Owner wants to validate whether something is worth pursuing
+- Owner asks about customer discovery, market validation, or testing assumptions
+- Owner wants to write a PRD or product brief
+- Phrases like "pressure test this idea", "is this worth building", "help me think through this"
+
+## Workflow
+
+Walk through each phase conversationally. Don't dump all phases at once — progress naturally based on where the owner is.
+
+**Phase 1 — Capture the idea.** Understand what they want to build and why. Load `references/discovery.md`.
+
+**Phase 2 — Validate assumptions.** Identify and test the riskiest assumptions. Load `references/validation.md`.
+
+**Phase 3 — Define the product.** Turn validated concepts into a clear PRD. Load `references/prd.md`.
+
+## References
+
+Load reference files on demand as each phase is reached — not all at once.
+
+- `references/discovery.md` — customer discovery framework, interview questions, market signals
+- `references/validation.md` — assumption mapping, validation techniques, go/no-go criteria
+- `references/prd.md` — PRD template, prioritisation, scope definition