openhome-cli 0.1.0 → 0.1.1

package/dist/cli.js

@@ -1,12 +1,14 @@
 import {
   getApiKey,
   getConfig,
+  getJwt as getJwt2,
   getTrackedAbilities,
   keychainDelete,
   registerAbility,
   saveApiKey,
-  saveConfig
-} from "./chunk-Q4UKUXDB.js";
+  saveConfig,
+  saveJwt
+} from "./chunk-OAKGNZQM.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -21,8 +23,7 @@ var ENDPOINTS = {
   getPersonalities: "/api/sdk/get_personalities",
   verifyApiKey: "/api/sdk/verify_apikey/",
   uploadCapability: "/api/capabilities/add-capability/",
-  listCapabilities: "/api/capabilities/get-all-capability/",
-  getCapability: (id) => `/api/capabilities/get-capability/${id}/`,
+  listCapabilities: "/api/capabilities/get-installed-capabilities/",
   deleteCapability: (id) => `/api/capabilities/delete-capability/${id}/`,
   bulkDeleteCapabilities: "/api/capabilities/delete-capability/",
   editInstalledCapability: (id) => `/api/capabilities/edit-installed-capability/${id}/`,
@@ -46,37 +47,39 @@ var ApiError = class extends Error {
   }
 };
 var ApiClient = class {
-  constructor(apiKey, baseUrl) {
+  constructor(apiKey, baseUrl, jwt) {
     this.apiKey = apiKey;
+    this.jwt = jwt;
     this.baseUrl = baseUrl ?? API_BASE;
     if (!this.baseUrl.startsWith("https://")) {
       throw new Error("API base URL must use HTTPS. Got: " + this.baseUrl);
     }
   }
   baseUrl;
-  async request(path, options = {}) {
+  async request(path, options = {}, useJwt = false) {
+    const token = useJwt ? this.jwt : this.apiKey;
     const url = `${this.baseUrl}${path}`;
     const response = await fetch(url, {
       ...options,
       headers: {
-        Authorization: `Bearer ${this.apiKey}`,
+        Authorization: `Bearer ${token}`,
         ...options.headers ?? {}
       }
     });
     if (!response.ok) {
+      if (response.status === 404) {
+        throw new NotImplementedError(path);
+      }
       let body = null;
       try {
         body = await response.json();
       } catch {
       }
-      if (body?.error?.code === "NOT_IMPLEMENTED" || response.status === 404) {
+      if (body?.error?.code === "NOT_IMPLEMENTED") {
         throw new NotImplementedError(path);
       }
-      throw new ApiError(
-        body?.error?.code ?? String(response.status),
-        body?.error?.message ?? response.statusText,
-        body?.error?.details
-      );
+      const message = body?.detail ?? body?.error?.message ?? response.statusText;
+      throw new ApiError(String(response.status), message);
     }
     return response.json();
   }
@@ -122,14 +125,36 @@ var ApiClient = class {
     });
   }
   async listAbilities() {
-    return this.request(ENDPOINTS.listCapabilities, {
-      method: "GET"
-    });
+    const data = await this.request(
+      ENDPOINTS.listCapabilities,
+      { method: "GET" },
+      true
+      // uses JWT
+    );
+    return {
+      abilities: data.map((c) => ({
+        ability_id: String(c.id),
+        unique_name: c.name,
+        display_name: c.name,
+        version: 1,
+        status: c.enabled ? "active" : "disabled",
+        personality_ids: [],
+        created_at: c.last_updated ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: c.last_updated ?? (/* @__PURE__ */ new Date()).toISOString(),
+        trigger_words: c.trigger_words,
+        category: c.category
+      }))
+    };
   }
   async getAbility(id) {
-    return this.request(ENDPOINTS.getCapability(id), {
-      method: "GET"
-    });
+    const { abilities } = await this.listAbilities();
+    const found = abilities.find(
+      (a) => a.ability_id === id || a.unique_name === id
+    );
+    if (!found) {
+      throw new ApiError("404", `Ability "${id}" not found.`);
+    }
+    return { ...found, validation_errors: [], deploy_history: [] };
   }
   async verifyApiKey(apiKey) {
     return this.request(ENDPOINTS.verifyApiKey, {
@@ -161,24 +186,39 @@ var ApiClient = class {
     }
   }
   async toggleCapability(id, enabled) {
+    const { abilities } = await this.listAbilities();
+    const current = abilities.find((a) => a.ability_id === id);
+    if (!current) {
+      throw new ApiError("404", `Ability "${id}" not found.`);
+    }
     return this.request(
       ENDPOINTS.editInstalledCapability(id),
       {
-        method: "POST",
+        method: "PUT",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ enabled })
-      }
+        body: JSON.stringify({
+          enabled,
+          name: current.unique_name,
+          category: current.category ?? "skill",
+          trigger_words: current.trigger_words ?? []
+        })
+      },
+      true
+      // uses JWT
     );
   }
   async assignCapabilities(personalityId, capabilityIds) {
-    return this.request(ENDPOINTS.editPersonality, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        personality_id: personalityId,
-        matching_capabilities: capabilityIds
-      })
-    });
+    const form = new FormData();
+    form.append("personality_id", personalityId);
+    for (const capId of capabilityIds) {
+      form.append("matching_capabilities", String(capId));
+    }
+    return this.request(
+      ENDPOINTS.editPersonality,
+      { method: "PUT", body: form },
+      true
+      // uses JWT
+    );
   }
 };
 
@@ -261,6 +301,24 @@ async function loginCommand() {
   }
   saveApiKey(apiKey);
   success("API key saved.");
+  p.note(
+    [
+      "Some features (list, toggle, delete, assign) require a session token.",
+      "To get it: go to app.openhome.com \u2192 open DevTools Console \u2192 run:",
+      "  localStorage.getItem('access_token')"
+    ].join("\n"),
+    "Optional: Session Token"
+  );
+  const jwtInput = await p.text({
+    message: "Paste your session token (or press Enter to skip)",
+    placeholder: "eyJhbGci..."
+  });
+  handleCancel(jwtInput);
+  const jwt = jwtInput?.trim();
+  if (jwt) {
+    saveJwt(jwt);
+    success("Session token saved.");
+  }
   if (agents.length > 0) {
     p.note(
       agents.map((a) => `${chalk2.bold(a.name)}  ${chalk2.gray(a.id)}`).join("\n"),
@@ -274,14 +332,14 @@ async function loginCommand() {
 
 // src/commands/init.ts
 import {
-  mkdirSync,
-  writeFileSync,
+  mkdirSync as mkdirSync2,
+  writeFileSync as writeFileSync2,
   copyFileSync,
-  existsSync as existsSync2,
-  readdirSync as readdirSync2
+  existsSync as existsSync3,
+  readdirSync as readdirSync3
 } from "fs";
-import { join as join2, resolve, extname } from "path";
-import { homedir } from "os";
+import { join as join3, resolve as resolve2, extname as extname2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/validation/validator.ts
 import { readFileSync, existsSync, readdirSync } from "fs";
@@ -492,112 +550,543 @@ function validateAbility(dirPath) {
   };
 }
 
-// src/commands/init.ts
-var DAEMON_TEMPLATES = /* @__PURE__ */ new Set(["background", "alarm"]);
-function toClassName(name) {
-  return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-var SHARED_INIT = "";
-function sharedConfig() {
-  return `{
-  "unique_name": "{{UNIQUE_NAME}}",
-  "description": "{{DESCRIPTION}}",
-  "category": "{{CATEGORY}}",
-  "matching_hotwords": {{HOTWORDS}}
-}
-`;
-}
-function skillReadme() {
-  return `# {{DISPLAY_NAME}}
-
-A custom OpenHome ability.
-
-## Trigger Words
+// src/commands/deploy.ts
+import { resolve, join as join2, basename, extname } from "path";
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  mkdirSync,
+  existsSync as existsSync2,
+  readdirSync as readdirSync2
+} from "fs";
+import { homedir } from "os";
 
-{{HOTWORD_LIST}}
-`;
+// src/util/zip.ts
+import archiver from "archiver";
+import { createWriteStream } from "fs";
+import { Writable } from "stream";
+async function createAbilityZip(dirPath) {
+  return new Promise((resolve5, reject) => {
+    const chunks = [];
+    const writable = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+    writable.on("finish", () => {
+      resolve5(Buffer.concat(chunks));
+    });
+    writable.on("error", reject);
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    archive.on("error", reject);
+    archive.pipe(writable);
+    archive.glob("**/*", {
+      cwd: dirPath,
+      ignore: [
+        "**/__pycache__/**",
+        "**/*.pyc",
+        "**/.git/**",
+        "**/.env",
+        "**/.env.*",
+        "**/secrets.*",
+        "**/*.key",
+        "**/*.pem"
+      ]
+    });
+    archive.finalize().catch(reject);
+  });
 }
-function daemonReadme() {
-  return `# {{DISPLAY_NAME}}
 
-A background OpenHome daemon. Runs automatically on session start \u2014 no trigger words required.
-
-## Trigger Words
+// src/api/mock-client.ts
+var MOCK_PERSONALITIES = [
+  { id: "pers_alice", name: "Alice", description: "Friendly assistant" },
+  { id: "pers_bob", name: "Bob", description: "Technical expert" },
+  { id: "pers_cara", name: "Cara", description: "Creative companion" }
+];
+var MOCK_ABILITIES = [
+  {
+    ability_id: "abl_weather_001",
+    unique_name: "weather-check",
+    display_name: "Weather Check",
+    version: 3,
+    status: "active",
+    personality_ids: ["pers_alice", "pers_bob"],
+    created_at: "2026-01-10T12:00:00Z",
+    updated_at: "2026-03-01T09:30:00Z"
+  },
+  {
+    ability_id: "abl_timer_002",
+    unique_name: "pomodoro-timer",
+    display_name: "Pomodoro Timer",
+    version: 1,
+    status: "processing",
+    personality_ids: ["pers_cara"],
+    created_at: "2026-03-18T08:00:00Z",
+    updated_at: "2026-03-18T08:05:00Z"
+  },
+  {
+    ability_id: "abl_news_003",
+    unique_name: "news-briefing",
+    display_name: "News Briefing",
+    version: 2,
+    status: "failed",
+    personality_ids: [],
+    created_at: "2026-02-20T14:00:00Z",
+    updated_at: "2026-02-21T10:00:00Z"
+  }
+];
+var MockApiClient = class {
+  async getPersonalities() {
+    return Promise.resolve(MOCK_PERSONALITIES);
+  }
+  async uploadAbility(_zipBuffer, _imageBuffer, _imageName, _metadata) {
+    return Promise.resolve({
+      ability_id: `abl_mock_${Date.now()}`,
+      unique_name: "mock-ability",
+      version: 1,
+      status: "processing",
+      validation_errors: [],
+      created_at: (/* @__PURE__ */ new Date()).toISOString(),
+      message: "[MOCK] Ability uploaded successfully and is being processed."
+    });
+  }
+  async listAbilities() {
+    return Promise.resolve({ abilities: MOCK_ABILITIES });
+  }
+  async verifyApiKey(_apiKey) {
+    return Promise.resolve({
+      valid: true,
+      message: "[MOCK] API key is valid."
+    });
+  }
+  async deleteCapability(id) {
+    return Promise.resolve({
+      message: `[MOCK] Capability ${id} deleted successfully.`
+    });
+  }
+  async toggleCapability(id, enabled) {
+    return Promise.resolve({
+      enabled,
+      message: `[MOCK] Capability ${id} ${enabled ? "enabled" : "disabled"}.`
+    });
+  }
+  async assignCapabilities(personalityId, capabilityIds) {
+    return Promise.resolve({
+      message: `[MOCK] Agent ${personalityId} updated with ${capabilityIds.length} capability(s).`
+    });
+  }
+  async getAbility(id) {
+    const found = MOCK_ABILITIES.find(
+      (a) => a.ability_id === id || a.unique_name === id
+    );
+    const base = found ?? MOCK_ABILITIES[0];
+    return Promise.resolve({
+      ...base,
+      validation_errors: base.status === "failed" ? ["Missing resume_normal_flow() call in main.py"] : [],
+      deploy_history: [
+        {
+          version: base.version,
+          status: base.status === "active" ? "success" : "failed",
+          timestamp: base.updated_at,
+          message: base.status === "active" ? "Deployed successfully" : "Validation failed"
+        },
+        ...base.version > 1 ? [
+          {
+            version: base.version - 1,
+            status: "success",
+            timestamp: base.created_at,
+            message: "Deployed successfully"
+          }
+        ] : []
+      ]
+    });
+  }
+};
 
-{{HOTWORD_LIST}}
-`;
+// src/commands/deploy.ts
+var IMAGE_EXTENSIONS = ["png", "jpg", "jpeg"];
+var ICON_NAMES = IMAGE_EXTENSIONS.flatMap((ext) => [
+  `icon.${ext}`,
+  `image.${ext}`,
+  `logo.${ext}`
+]);
+function findIcon(dir) {
+  for (const name of ICON_NAMES) {
+    const p2 = join2(dir, name);
+    if (existsSync2(p2)) return p2;
+  }
+  return null;
 }
-function getTemplate(templateType, file) {
-  if (file === "config.json") return sharedConfig();
-  if (file === "__init__.py") return SHARED_INIT;
-  if (file === "README.md") {
-    return DAEMON_TEMPLATES.has(templateType) ? daemonReadme() : skillReadme();
+async function resolveAbilityDir(pathArg) {
+  if (pathArg && pathArg !== ".") {
+    return resolve(pathArg);
   }
-  const templates = {
-    // ── BASIC ────────────────────────────────────────────────────────────
-    basic: {
-      "main.py": `from src.agent.capability import MatchingCapability
-from src.main import AgentWorker
-from src.agent.capability_worker import CapabilityWorker
-
-
-class {{CLASS_NAME}}(MatchingCapability):
-    worker: AgentWorker = None
-    capability_worker: CapabilityWorker = None
-
-    @classmethod
-    def register_capability(cls) -> "MatchingCapability":
-        # {{register_capability}}
-        pass
-
-    def call(self, worker: AgentWorker):
-        self.worker = worker
-        self.capability_worker = CapabilityWorker(self.worker)
-        self.worker.session_tasks.create(self.run())
+  const tracked = getTrackedAbilities();
+  const cwd = process.cwd();
+  const cwdIsAbility = existsSync2(resolve(cwd, "config.json"));
+  if (cwdIsAbility) {
+    info(`Detected ability in current directory`);
+    return cwd;
+  }
+  const options = [];
+  for (const a of tracked) {
+    const home = homedir();
+    options.push({
+      value: a.path,
+      label: a.name,
+      hint: a.path.startsWith(home) ? `~${a.path.slice(home.length)}` : a.path
+    });
+  }
+  if (options.length === 1) {
+    info(`Using ability: ${options[0].label} (${options[0].hint})`);
+    return options[0].value;
+  }
+  if (options.length > 0) {
+    options.push({
+      value: "__custom__",
+      label: "Other...",
+      hint: "Enter a path manually"
+    });
+    const selected = await p.select({
+      message: "Which ability do you want to deploy?",
+      options
+    });
+    handleCancel(selected);
+    if (selected !== "__custom__") {
+      return selected;
+    }
+  }
+  const pathInput = await p.text({
+    message: "Path to ability directory",
+    placeholder: "./my-ability",
+    validate: (val) => {
+      if (!val || !val.trim()) return "Path is required";
+      if (!existsSync2(resolve(val.trim(), "config.json"))) {
+        return `No config.json found in "${val.trim()}"`;
+      }
+    }
+  });
+  handleCancel(pathInput);
+  return resolve(pathInput.trim());
+}
+async function deployCommand(pathArg, opts = {}) {
+  p.intro("\u{1F680} Deploy ability");
+  const targetDir = await resolveAbilityDir(pathArg);
+  const s = p.spinner();
+  s.start("Validating ability...");
+  const validation = validateAbility(targetDir);
+  if (!validation.passed) {
+    s.stop("Validation failed.");
+    for (const issue of validation.errors) {
+      error(`  ${issue.file ? `[${issue.file}] ` : ""}${issue.message}`);
+    }
+    process.exit(1);
+  }
+  s.stop("Validation passed.");
+  if (validation.warnings.length > 0) {
+    for (const w of validation.warnings) {
+      warn(`  ${w.file ? `[${w.file}] ` : ""}${w.message}`);
+    }
+  }
+  const configPath = join2(targetDir, "config.json");
+  let abilityConfig;
+  try {
+    abilityConfig = JSON.parse(
+      readFileSync2(configPath, "utf8")
+    );
+  } catch {
+    error("Could not read config.json");
+    process.exit(1);
+  }
+  const uniqueName = abilityConfig.unique_name;
+  const hotwords = abilityConfig.matching_hotwords ?? [];
+  let description = abilityConfig.description?.trim();
+  if (!description) {
+    const descInput = await p.text({
+      message: "Ability description (required for marketplace)",
+      placeholder: "A fun ability that does something cool",
+      validate: (val) => {
+        if (!val || !val.trim()) return "Description is required";
+      }
+    });
+    handleCancel(descInput);
+    description = descInput.trim();
+  }
+  let category = abilityConfig.category;
+  if (!category || !["skill", "brain", "daemon"].includes(category)) {
+    const catChoice = await p.select({
+      message: "Ability category",
+      options: [
+        { value: "skill", label: "Skill", hint: "User-triggered" },
+        { value: "brain", label: "Brain Skill", hint: "Auto-triggered" },
+        {
+          value: "daemon",
+          label: "Background Daemon",
+          hint: "Runs continuously"
+        }
+      ]
+    });
+    handleCancel(catChoice);
+    category = catChoice;
+  }
+  let imagePath = findIcon(targetDir);
+  if (imagePath) {
+    info(`Found icon: ${basename(imagePath)}`);
+  } else {
+    const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
+    const home = homedir();
+    const scanDirs = [
+      .../* @__PURE__ */ new Set([
+        process.cwd(),
+        targetDir,
+        join2(home, "Desktop"),
+        join2(home, "Downloads"),
+        join2(home, "Pictures"),
+        join2(home, "Images"),
+        join2(home, ".openhome", "icons")
+      ])
+    ];
+    const foundImages = [];
+    for (const dir of scanDirs) {
+      if (!existsSync2(dir)) continue;
+      try {
+        for (const file of readdirSync2(dir)) {
+          if (IMAGE_EXTS.has(extname(file).toLowerCase())) {
+            const full = join2(dir, file);
+            const shortDir = dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
+            foundImages.push({
+              path: full,
+              label: `${file}  (${shortDir})`
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    if (foundImages.length > 0) {
+      const imageOptions = [
+        ...foundImages.map((img) => ({ value: img.path, label: img.label })),
+        {
+          value: "__custom__",
+          label: "Other...",
+          hint: "Enter a path manually"
+        },
+        {
+          value: "__skip__",
+          label: "Skip",
+          hint: "Upload without an icon (optional)"
+        }
+      ];
+      const selected = await p.select({
+        message: "Select an icon image (optional)",
+        options: imageOptions
+      });
+      handleCancel(selected);
+      if (selected === "__custom__") {
+        const imgInput = await p.text({
+          message: "Path to icon image",
+          placeholder: "./icon.png",
+          validate: (val) => {
+            if (!val || !val.trim()) return void 0;
+            const resolved = resolve(val.trim());
+            if (!existsSync2(resolved)) return `File not found: ${val.trim()}`;
+            if (!IMAGE_EXTS.has(extname(resolved).toLowerCase()))
+              return "Image must be PNG or JPG";
+          }
+        });
+        handleCancel(imgInput);
+        const trimmed = imgInput.trim();
+        if (trimmed) imagePath = resolve(trimmed);
+      } else if (selected !== "__skip__") {
+        imagePath = selected;
+      }
+    } else {
+      const imgInput = await p.text({
+        message: "Path to ability icon image (PNG or JPG, optional \u2014 press Enter to skip)",
+        placeholder: "./icon.png",
+        validate: (val) => {
+          if (!val || !val.trim()) return void 0;
+          const resolved = resolve(val.trim());
+          if (!existsSync2(resolved)) return `File not found: ${val.trim()}`;
+          if (!IMAGE_EXTS.has(extname(resolved).toLowerCase()))
+            return "Image must be PNG or JPG";
+        }
+      });
+      handleCancel(imgInput);
+      const trimmed = imgInput.trim();
+      if (trimmed) imagePath = resolve(trimmed);
+    }
+  }
+  const imageBuffer = imagePath ? readFileSync2(imagePath) : null;
+  const imageName = imagePath ? basename(imagePath) : null;
+  const personalityId = opts.personality ?? getConfig().default_personality_id;
+  const metadata = {
+    name: uniqueName,
+    description,
+    category,
+    matching_hotwords: hotwords,
+    personality_id: personalityId
+  };
+  if (opts.dryRun) {
+    p.note(
+      [
+        `Directory:   ${targetDir}`,
+        `Name:        ${uniqueName}`,
+        `Description: ${description}`,
+        `Category:    ${category}`,
+        `Image:       ${imageName ?? "(none)"}`,
+        `Hotwords:    ${hotwords.join(", ")}`,
+        `Agent:       ${personalityId ?? "(none set)"}`
+      ].join("\n"),
+      "Dry Run \u2014 would deploy"
+    );
+    p.outro("No changes made.");
+    return;
+  }
+  s.start("Creating ability zip...");
+  let zipBuffer;
+  try {
+    zipBuffer = await createAbilityZip(targetDir);
+    s.stop(`Zip created (${(zipBuffer.length / 1024).toFixed(1)} KB)`);
+  } catch (err) {
+    s.stop("Failed to create zip.");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  if (opts.mock) {
+    s.start("Uploading ability (mock)...");
+    const mockClient = new MockApiClient();
+    const result = await mockClient.uploadAbility(
+      zipBuffer,
+      imageBuffer,
+      imageName,
+      metadata
+    );
+    s.stop("Upload complete.");
+    p.note(
+      [
+        `Ability ID: ${result.ability_id}`,
+        `Status:     ${result.status}`,
+        `Message:    ${result.message}`
+      ].join("\n"),
+      "Mock Deploy Result"
+    );
+    p.outro("Mock deploy complete.");
+    return;
+  }
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not authenticated. Run: openhome login");
+    process.exit(1);
+  }
+  const confirmed = await p.confirm({
+    message: `Deploy "${uniqueName}" to OpenHome?`
+  });
+  handleCancel(confirmed);
+  if (!confirmed) {
+    p.cancel("Aborted.");
+    process.exit(0);
+  }
+  s.start("Uploading ability...");
+  try {
+    const client = new ApiClient(apiKey, getConfig().api_base_url);
+    const result = await client.uploadAbility(
+      zipBuffer,
+      imageBuffer,
+      imageName,
+      metadata
+    );
+    s.stop("Upload complete.");
+    p.note(
+      [
+        `Ability ID: ${result.ability_id}`,
+        `Version:    ${result.version}`,
+        `Status:     ${result.status}`,
+        result.message ? `Message:    ${result.message}` : ""
+      ].filter(Boolean).join("\n"),
+      "Deploy Result"
+    );
+    p.outro("Deployed successfully! \u{1F389}");
+  } catch (err) {
+    s.stop("Upload failed.");
+    if (err instanceof NotImplementedError) {
+      warn("This API endpoint is not yet available on the OpenHome server.");
+      const outDir = join2(homedir(), ".openhome");
+      mkdirSync(outDir, { recursive: true });
+      const outPath = join2(outDir, "last-deploy.zip");
+      writeFileSync(outPath, zipBuffer);
+      p.note(
+        [
+          `Your ability was validated and zipped successfully.`,
+          `Zip saved to: ${outPath}`,
+          ``,
+          `Upload manually at https://app.openhome.com`
+        ].join("\n"),
+        "API Not Available Yet"
+      );
+      p.outro("Zip ready for manual upload.");
+      return;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.toLowerCase().includes("same name")) {
+      error(`An ability named "${uniqueName}" already exists.`);
+      warn(
+        `To update it, delete it first with: openhome delete
+Or rename it in config.json and redeploy.`
+      );
+    } else {
+      error(`Deploy failed: ${msg}`);
+    }
+    process.exit(1);
+  }
+}
 
-    async def run(self):
-        await self.capability_worker.speak("Hello! This ability is working.")
-        self.capability_worker.resume_normal_flow()
-`
-    },
-    // ── API ──────────────────────────────────────────────────────────────
-    api: {
-      "main.py": `import requests
-from src.agent.capability import MatchingCapability
-from src.main import AgentWorker
-from src.agent.capability_worker import CapabilityWorker
+// src/commands/init.ts
+var DAEMON_TEMPLATES = /* @__PURE__ */ new Set(["background", "alarm"]);
+function toClassName(name) {
+  return name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+var SHARED_INIT = "";
+function sharedConfig() {
+  return `{
+  "unique_name": "{{UNIQUE_NAME}}",
+  "description": "{{DESCRIPTION}}",
+  "category": "{{CATEGORY}}",
+  "matching_hotwords": {{HOTWORDS}}
+}
+`;
+}
+function skillReadme() {
+  return `# {{DISPLAY_NAME}}
 
+A custom OpenHome ability.
 
-class {{CLASS_NAME}}(MatchingCapability):
-    worker: AgentWorker = None
-    capability_worker: CapabilityWorker = None
+## Trigger Words
 
-    @classmethod
-    def register_capability(cls) -> "MatchingCapability":
-        # {{register_capability}}
-        pass
+{{HOTWORD_LIST}}
+`;
+}
+function daemonReadme() {
+  return `# {{DISPLAY_NAME}}
 
-    def call(self, worker: AgentWorker):
-        self.worker = worker
-        self.capability_worker = CapabilityWorker(self.worker)
-        self.worker.session_tasks.create(self.run())
+A background OpenHome daemon. Runs automatically on session start \u2014 no trigger words required.
 
-    async def run(self):
-        api_key = self.capability_worker.get_single_key("api_key")
-        response = requests.get(
-            "https://api.example.com/data",
-            headers={"Authorization": f"Bearer {api_key}"},
-            timeout=10,
-        )
-        data = response.json()
-        await self.capability_worker.speak(f"Here's what I found: {data.get('result', 'nothing')}")
-        self.capability_worker.resume_normal_flow()
-`
-    },
-    // ── LOOP ─────────────────────────────────────────────────────────────
-    loop: {
-      "main.py": `import asyncio
-from src.agent.capability import MatchingCapability
+## Trigger Words
+
+{{HOTWORD_LIST}}
+`;
+}
+function getTemplate(templateType, file) {
+  if (file === "config.json") return sharedConfig();
+  if (file === "__init__.py") return SHARED_INIT;
+  if (file === "README.md") {
+    return DAEMON_TEMPLATES.has(templateType) ? daemonReadme() : skillReadme();
+  }
+  const templates = {
+    // ── BASIC ────────────────────────────────────────────────────────────
+    basic: {
+      "main.py": `from src.agent.capability import MatchingCapability
 from src.main import AgentWorker
 from src.agent.capability_worker import CapabilityWorker
 
@@ -617,33 +1106,13 @@ class {{CLASS_NAME}}(MatchingCapability):
         self.worker.session_tasks.create(self.run())
 
     async def run(self):
-        await self.capability_worker.speak("I'll listen and check in periodically.")
-
-        while True:
-            self.capability_worker.start_audio_recording()
-            await self.worker.session_tasks.sleep(90)
-            self.capability_worker.stop_audio_recording()
-
-            recording = self.capability_worker.get_audio_recording()
-            length = self.capability_worker.get_audio_recording_length()
-            self.capability_worker.flush_audio_recording()
-
-            if length > 2:
-                response = self.capability_worker.text_to_text_response(
-                    f"The user has been speaking for {length:.0f} seconds. "
-                    "Summarize what you heard and respond helpfully.",
-                    self.capability_worker.get_full_message_history(),
-                )
-                await self.capability_worker.speak(response)
-
+        await self.capability_worker.speak("Hello! This ability is working.")
         self.capability_worker.resume_normal_flow()
 `
     },
-    // ── EMAIL ────────────────────────────────────────────────────────────
-    email: {
-      "main.py": `import json
-import smtplib
-from email.mime.text import MIMEText
+    // ── API ──────────────────────────────────────────────────────────────
+    api: {
+      "main.py": `import requests
 from src.agent.capability import MatchingCapability
 from src.main import AgentWorker
 from src.agent.capability_worker import CapabilityWorker
@@ -664,154 +1133,26 @@ class {{CLASS_NAME}}(MatchingCapability):
         self.worker.session_tasks.create(self.run())
 
     async def run(self):
-        creds = self.capability_worker.get_single_key("email_config")
-        if not creds:
-            await self.capability_worker.speak("Email is not configured yet.")
-            self.capability_worker.resume_normal_flow()
-            return
-
-        config = json.loads(creds) if isinstance(creds, str) else creds
-
-        reply = await self.capability_worker.run_io_loop(
-            "Who should I send the email to?"
-        )
-        to_addr = reply.strip()
-
-        subject = await self.capability_worker.run_io_loop("What's the subject?")
-        body = await self.capability_worker.run_io_loop("What should the email say?")
-
-        confirmed = await self.capability_worker.run_confirmation_loop(
-            f"Send email to {to_addr} with subject '{subject}'?"
+        api_key = self.capability_worker.get_single_key("api_key")
+        response = requests.get(
+            "https://api.example.com/data",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10,
         )
-
-        if confirmed:
-            msg = MIMEText(body)
-            msg["Subject"] = subject
-            msg["From"] = config["from"]
-            msg["To"] = to_addr
-
-            try:
-                with smtplib.SMTP(config["smtp_host"], config.get("smtp_port", 587)) as server:
-                    server.starttls()
-                    server.login(config["from"], config["password"])
-                    server.send_message(msg)
-                await self.capability_worker.speak("Email sent!")
-            except Exception as e:
-                self.worker.editor_logging_handler.error(f"Email failed: {e}")
-                await self.capability_worker.speak("Sorry, the email failed to send.")
-        else:
-            await self.capability_worker.speak("Email cancelled.")
-
-        self.capability_worker.resume_normal_flow()
-`
-    },
-    // ── BACKGROUND (daemon) ───────────────────────────────────────────────
-    // background.py holds the active logic; main.py is a minimal no-op stub
-    background: {
-      "main.py": `from src.agent.capability import MatchingCapability
-from src.main import AgentWorker
-from src.agent.capability_worker import CapabilityWorker
-
-
-class {{CLASS_NAME}}(MatchingCapability):
-    worker: AgentWorker = None
-    capability_worker: CapabilityWorker = None
-
-    @classmethod
-    def register_capability(cls) -> "MatchingCapability":
-        # {{register_capability}}
-        pass
-
-    def call(self, worker: AgentWorker):
-        self.worker = worker
-        self.capability_worker = CapabilityWorker(self.worker)
-        self.worker.session_tasks.create(self.run())
-
-    async def run(self):
+        data = response.json()
+        await self.capability_worker.speak(f"Here's what I found: {data.get('result', 'nothing')}")
         self.capability_worker.resume_normal_flow()
-`,
-      "background.py": `import asyncio
-from src.agent.capability import MatchingCapability
-from src.main import AgentWorker
-from src.agent.capability_worker import CapabilityWorker
-
-
-class {{CLASS_NAME}}(MatchingCapability):
-    worker: AgentWorker = None
-    capability_worker: CapabilityWorker = None
-
-    @classmethod
-    def register_capability(cls) -> "MatchingCapability":
-        # {{register_capability}}
-        pass
-
-    def call(self, worker: AgentWorker):
-        self.worker = worker
-        self.capability_worker = CapabilityWorker(self.worker)
-        self.worker.session_tasks.create(self.run())
-
-    async def run(self):
-        while True:
-            # Your background logic here
-            self.worker.editor_logging_handler.info("Background tick")
-
-            # Example: check something and notify
-            # await self.capability_worker.speak("Heads up!")
-
-            await self.worker.session_tasks.sleep(60)
 `
     },
-    // ── ALARM (skill + daemon combo) ──────────────────────────────────────
-    alarm: {
-      "main.py": `from src.agent.capability import MatchingCapability
-from src.main import AgentWorker
-from src.agent.capability_worker import CapabilityWorker
-
-
-class {{CLASS_NAME}}(MatchingCapability):
-    worker: AgentWorker = None
-    capability_worker: CapabilityWorker = None
-
-    @classmethod
-    def register_capability(cls) -> "MatchingCapability":
-        # {{register_capability}}
-        pass
-
-    def call(self, worker: AgentWorker):
-        self.worker = worker
-        self.capability_worker = CapabilityWorker(self.worker)
-        self.worker.session_tasks.create(self.run())
-
-    async def run(self):
-        reply = await self.capability_worker.run_io_loop(
-            "What should I remind you about?"
-        )
-        minutes = await self.capability_worker.run_io_loop(
-            "In how many minutes?"
-        )
-
-        try:
-            mins = int(minutes.strip())
-        except ValueError:
-            await self.capability_worker.speak("I didn't understand the time. Try again.")
-            self.capability_worker.resume_normal_flow()
-            return
-
-        self.capability_worker.write_file(
-            "pending_alarm.json",
-            f'{{"message": "{reply}", "minutes": {mins}}}',
-            temp=True,
-        )
-        await self.capability_worker.speak(f"Got it! I'll remind you in {mins} minutes.")
-        self.capability_worker.resume_normal_flow()
-`,
-      "background.py": `import json
+    // ── LOOP ─────────────────────────────────────────────────────────────
+    loop: {
+      "main.py": `import asyncio
 from src.agent.capability import MatchingCapability
 from src.main import AgentWorker
 from src.agent.capability_worker import CapabilityWorker
 
 
-class {{CLASS_NAME}}Background(MatchingCapability):
+class {{CLASS_NAME}}(MatchingCapability):
     worker: AgentWorker = None
     capability_worker: CapabilityWorker = None
 
@@ -826,19 +1167,33 @@ class {{CLASS_NAME}}Background(MatchingCapability):
         self.worker.session_tasks.create(self.run())
 
     async def run(self):
+        await self.capability_worker.speak("I'll listen and check in periodically.")
+
         while True:
-            if self.capability_worker.check_if_file_exists("pending_alarm.json", temp=True):
-                raw = self.capability_worker.read_file("pending_alarm.json", temp=True)
-                alarm = json.loads(raw)
-                await self.worker.session_tasks.sleep(alarm["minutes"] * 60)
-                await self.capability_worker.speak(f"Reminder: {alarm['message']}")
-                self.capability_worker.delete_file("pending_alarm.json", temp=True)
-            await self.worker.session_tasks.sleep(10)
+            self.capability_worker.start_audio_recording()
+            await self.worker.session_tasks.sleep(90)
+            self.capability_worker.stop_audio_recording()
+
+            recording = self.capability_worker.get_audio_recording()
+            length = self.capability_worker.get_audio_recording_length()
+            self.capability_worker.flush_audio_recording()
+
+            if length > 2:
+                response = self.capability_worker.text_to_text_response(
+                    f"The user has been speaking for {length:.0f} seconds. "
+                    "Summarize what you heard and respond helpfully.",
+                    self.capability_worker.get_full_message_history(),
+                )
+                await self.capability_worker.speak(response)
+
+        self.capability_worker.resume_normal_flow()
 `
     },
-    // ── READWRITE ────────────────────────────────────────────────────────
-    readwrite: {
+    // ── EMAIL ────────────────────────────────────────────────────────────
+    email: {
       "main.py": `import json
+import smtplib
+from email.mime.text import MIMEText
 from src.agent.capability import MatchingCapability
 from src.main import AgentWorker
 from src.agent.capability_worker import CapabilityWorker
@@ -859,33 +1214,50 @@ class {{CLASS_NAME}}(MatchingCapability):
         self.worker.session_tasks.create(self.run())
 
     async def run(self):
+        creds = self.capability_worker.get_single_key("email_config")
+        if not creds:
+            await self.capability_worker.speak("Email is not configured yet.")
+            self.capability_worker.resume_normal_flow()
+            return
+
+        config = json.loads(creds) if isinstance(creds, str) else creds
+
         reply = await self.capability_worker.run_io_loop(
-            "What would you like me to remember?"
+            "Who should I send the email to?"
         )
+        to_addr = reply.strip()
 
-        # Read existing notes or start fresh
-        if self.capability_worker.check_if_file_exists("notes.json", temp=False):
-            raw = self.capability_worker.read_file("notes.json", temp=False)
-            notes = json.loads(raw)
-        else:
-            notes = []
+        subject = await self.capability_worker.run_io_loop("What's the subject?")
+        body = await self.capability_worker.run_io_loop("What should the email say?")
 
-        notes.append(reply.strip())
-        self.capability_worker.write_file(
-            "notes.json",
-            json.dumps(notes, indent=2),
-            temp=False,
-            mode="w",
+        confirmed = await self.capability_worker.run_confirmation_loop(
+            f"Send email to {to_addr} with subject '{subject}'?"
         )
 
-        await self.capability_worker.speak(
-            f"Got it! I now have {len(notes)} note{'s' if len(notes) != 1 else ''} saved."
-        )
+        if confirmed:
+            msg = MIMEText(body)
+            msg["Subject"] = subject
+            msg["From"] = config["from"]
+            msg["To"] = to_addr
+
+            try:
+                with smtplib.SMTP(config["smtp_host"], config.get("smtp_port", 587)) as server:
+                    server.starttls()
+                    server.login(config["from"], config["password"])
+                    server.send_message(msg)
+                await self.capability_worker.speak("Email sent!")
+            except Exception as e:
+                self.worker.editor_logging_handler.error(f"Email failed: {e}")
+                await self.capability_worker.speak("Sorry, the email failed to send.")
+        else:
+            await self.capability_worker.speak("Email cancelled.")
+
         self.capability_worker.resume_normal_flow()
 `
     },
-    // ── LOCAL ────────────────────────────────────────────────────────────
-    local: {
+    // ── BACKGROUND (daemon) ───────────────────────────────────────────────
+    // background.py holds the active logic; main.py is a minimal no-op stub
+    background: {
       "main.py": `from src.agent.capability import MatchingCapability
 from src.main import AgentWorker
 from src.agent.capability_worker import CapabilityWorker
@@ -906,30 +1278,42 @@ class {{CLASS_NAME}}(MatchingCapability):
         self.worker.session_tasks.create(self.run())
 
     async def run(self):
-        reply = await self.capability_worker.run_io_loop(
-            "What would you like me to do on your device?"
-        )
+        self.capability_worker.resume_normal_flow()
+`,
+      "background.py": `import asyncio
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
 
-        # Use text_to_text to interpret the command
-        response = self.capability_worker.text_to_text_response(
-            f"The user wants to: {reply}. Generate a helpful response.",
-            self.capability_worker.get_full_message_history(),
-        )
 
-        # Send action to DevKit hardware if connected
-        self.capability_worker.send_devkit_action({
-            "type": "command",
-            "payload": reply.strip(),
-        })
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
 
-        await self.capability_worker.speak(response)
-        self.capability_worker.resume_normal_flow()
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        while True:
+            # Your background logic here
+            self.worker.editor_logging_handler.info("Background tick")
+
+            # Example: check something and notify
+            # await self.capability_worker.speak("Heads up!")
+
+            await self.worker.session_tasks.sleep(60)
 `
     },
-    // ── OPENCLAW ─────────────────────────────────────────────────────────
-    openclaw: {
-      "main.py": `import requests
-from src.agent.capability import MatchingCapability
+    // ── ALARM (skill + daemon combo) ──────────────────────────────────────
+    alarm: {
+      "main.py": `from src.agent.capability import MatchingCapability
 from src.main import AgentWorker
 from src.agent.capability_worker import CapabilityWorker
 
@@ -950,821 +1334,504 @@ class {{CLASS_NAME}}(MatchingCapability):
 
     async def run(self):
         reply = await self.capability_worker.run_io_loop(
-            "What would you like me to handle?"
+            "What should I remind you about?"
+        )
+        minutes = await self.capability_worker.run_io_loop(
+            "In how many minutes?"
         )
 
-        gateway_url = self.capability_worker.get_single_key("openclaw_gateway_url")
-        gateway_token = self.capability_worker.get_single_key("openclaw_gateway_token")
-
-        if not gateway_url or not gateway_token:
-            await self.capability_worker.speak(
-                "OpenClaw gateway is not configured. Add openclaw_gateway_url and openclaw_gateway_token as secrets."
-            )
+        try:
+            mins = int(minutes.strip())
+        except ValueError:
+            await self.capability_worker.speak("I didn't understand the time. Try again.")
             self.capability_worker.resume_normal_flow()
             return
 
-        try:
-            resp = requests.post(
-                f"{gateway_url}/v1/chat",
-                headers={
-                    "Authorization": f"Bearer {gateway_token}",
-                    "Content-Type": "application/json",
-                },
-                json={"message": reply.strip()},
-                timeout=30,
-            )
-            data = resp.json()
-            answer = data.get("reply", data.get("response", "No response from OpenClaw."))
-            await self.capability_worker.speak(answer)
-        except Exception as e:
-            self.worker.editor_logging_handler.error(f"OpenClaw error: {e}")
-            await self.capability_worker.speak("Sorry, I couldn't reach OpenClaw.")
-
-        self.capability_worker.resume_normal_flow()
-`
-    }
-  };
-  return templates[templateType]?.[file] ?? "";
-}
-function applyTemplate(content, vars) {
-  let result = content;
-  for (const [key, value] of Object.entries(vars)) {
-    result = result.replaceAll(`{{${key}}}`, value);
-  }
-  return result;
-}
-function getFileList(templateType) {
-  const base = ["__init__.py", "README.md", "config.json"];
-  if (templateType === "background") {
-    return ["main.py", "background.py", ...base];
-  }
-  if (templateType === "alarm") {
-    return ["main.py", "background.py", ...base];
-  }
-  return ["main.py", ...base];
-}
-function getTemplateOptions(category) {
-  if (category === "skill") {
-    return [
-      {
-        value: "basic",
-        label: "Basic",
-        hint: "Simple ability with speak + user_response"
-      },
-      {
-        value: "api",
-        label: "API",
-        hint: "Calls an external API using a stored secret"
-      },
-      {
-        value: "loop",
-        label: "Loop (ambient observer)",
-        hint: "Records audio periodically and checks in"
-      },
-      {
-        value: "email",
-        label: "Email",
-        hint: "Sends email via SMTP using stored credentials"
-      },
-      {
-        value: "readwrite",
-        label: "File Storage",
-        hint: "Reads and writes persistent JSON files"
-      },
-      {
-        value: "local",
-        label: "Local (DevKit)",
-        hint: "Executes commands on the local device via DevKit"
-      },
-      {
-        value: "openclaw",
-        label: "OpenClaw",
-        hint: "Forwards requests to the OpenClaw gateway"
-      }
-    ];
-  }
-  if (category === "brain") {
-    return [
-      {
-        value: "basic",
-        label: "Basic",
-        hint: "Simple ability with speak + user_response"
-      },
-      {
-        value: "api",
-        label: "API",
-        hint: "Calls an external API using a stored secret"
-      }
-    ];
-  }
-  return [
-    {
-      value: "background",
-      label: "Background (continuous)",
-      hint: "Runs a loop from session start, no trigger"
+        self.capability_worker.write_file(
+            "pending_alarm.json",
+            f'{{"message": "{reply}", "minutes": {mins}}}',
+            temp=True,
+        )
+        await self.capability_worker.speak(f"Got it! I'll remind you in {mins} minutes.")
+        self.capability_worker.resume_normal_flow()
+`,
+      "background.py": `import json
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}Background(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        while True:
+            if self.capability_worker.check_if_file_exists("pending_alarm.json", temp=True):
+                raw = self.capability_worker.read_file("pending_alarm.json", temp=True)
+                alarm = json.loads(raw)
+                await self.worker.session_tasks.sleep(alarm["minutes"] * 60)
+                await self.capability_worker.speak(f"Reminder: {alarm['message']}")
+                self.capability_worker.delete_file("pending_alarm.json", temp=True)
+            await self.worker.session_tasks.sleep(10)
+`
     },
-    {
-      value: "alarm",
-      label: "Alarm (skill + daemon combo)",
-      hint: "Skill sets an alarm; background.py fires it"
-    }
-  ];
-}
-async function initCommand(nameArg) {
-  p.intro("Create a new OpenHome ability");
-  let name;
-  if (nameArg) {
-    name = nameArg.trim();
-    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
-      error(
-        "Invalid name. Use lowercase letters, numbers, and hyphens only. Must start with a letter."
-      );
-      process.exit(1);
-    }
-  } else {
-    const nameInput = await p.text({
-      message: "What should your ability be called?",
-      placeholder: "my-cool-ability",
-      validate: (val) => {
-        if (!val || !val.trim()) return "Name is required";
-        if (!/^[a-z][a-z0-9-]*$/.test(val.trim()))
-          return "Use lowercase letters, numbers, and hyphens only. Must start with a letter.";
-      }
-    });
-    handleCancel(nameInput);
-    name = nameInput.trim();
-  }
-  const category = await p.select({
-    message: "What type of ability?",
-    options: [
-      {
-        value: "skill",
-        label: "Skill",
-        hint: "User-triggered, runs on demand (most common)"
-      },
-      {
-        value: "brain",
-        label: "Brain Skill",
-        hint: "Auto-triggered by the agent's intelligence"
-      },
-      {
-        value: "daemon",
-        label: "Background Daemon",
-        hint: "Runs continuously from session start"
-      }
-    ]
-  });
-  handleCancel(category);
-  const descInput = await p.text({
-    message: "Short description for the marketplace",
-    placeholder: "A fun ability that checks the weather",
-    validate: (val) => {
-      if (!val || !val.trim()) return "Description is required";
-    }
-  });
-  handleCancel(descInput);
-  const description = descInput.trim();
-  const templateOptions = getTemplateOptions(category);
-  const templateType = await p.select({
-    message: "Choose a template",
-    options: templateOptions
-  });
-  handleCancel(templateType);
-  const hotwordInput = await p.text({
-    message: DAEMON_TEMPLATES.has(templateType) ? "Trigger words (comma-separated, or leave empty for daemons)" : "Trigger words (comma-separated)",
-    placeholder: "check weather, weather please",
-    validate: (val) => {
-      if (!DAEMON_TEMPLATES.has(templateType)) {
-        if (!val || !val.trim()) return "At least one trigger word is required";
-      }
-    }
-  });
-  handleCancel(hotwordInput);
-  const hotwords = hotwordInput.split(",").map((h) => h.trim()).filter(Boolean);
-  const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
-  const home = homedir();
-  const candidateDirs = [
-    process.cwd(),
-    join2(home, "Desktop"),
-    join2(home, "Downloads"),
-    join2(home, "Pictures"),
-    join2(home, "Images"),
-    join2(home, ".openhome", "icons")
-  ];
-  if (process.env.USERPROFILE) {
-    candidateDirs.push(
-      join2(process.env.USERPROFILE, "Desktop"),
-      join2(process.env.USERPROFILE, "Downloads"),
-      join2(process.env.USERPROFILE, "Pictures")
-    );
-  }
-  const scanDirs = [...new Set(candidateDirs)];
-  const foundImages = [];
-  for (const dir of scanDirs) {
-    if (!existsSync2(dir)) continue;
-    try {
-      const files2 = readdirSync2(dir);
-      for (const file of files2) {
-        if (IMAGE_EXTS.has(extname(file).toLowerCase())) {
-          const full = join2(dir, file);
-          const shortDir = dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
-          foundImages.push({
-            path: full,
-            label: `${file}  (${shortDir})`
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  let iconSourcePath;
-  if (foundImages.length > 0) {
-    const imageOptions = [
-      ...foundImages.map((img) => ({ value: img.path, label: img.label })),
-      { value: "__custom__", label: "Other...", hint: "Enter a path manually" }
-    ];
-    const selected = await p.select({
-      message: "Select an icon image (PNG or JPG for marketplace)",
-      options: imageOptions
-    });
-    handleCancel(selected);
-    if (selected === "__custom__") {
-      const iconInput = await p.text({
-        message: "Path to icon image",
-        placeholder: "./icon.png",
-        validate: (val) => {
-          if (!val || !val.trim()) return "An icon image is required";
-          const resolved = resolve(val.trim());
-          if (!existsSync2(resolved)) return `File not found: ${val.trim()}`;
-          const ext = extname(resolved).toLowerCase();
-          if (!IMAGE_EXTS.has(ext)) return "Image must be PNG or JPG";
-        }
-      });
-      handleCancel(iconInput);
-      iconSourcePath = resolve(iconInput.trim());
-    } else {
-      iconSourcePath = selected;
-    }
-  } else {
-    const iconInput = await p.text({
-      message: "Path to icon image (PNG or JPG for marketplace)",
-      placeholder: "./icon.png",
-      validate: (val) => {
-        if (!val || !val.trim()) return "An icon image is required";
-        const resolved = resolve(val.trim());
-        if (!existsSync2(resolved)) return `File not found: ${val.trim()}`;
-        const ext = extname(resolved).toLowerCase();
-        if (!IMAGE_EXTS.has(ext)) return "Image must be PNG or JPG";
-      }
-    });
-    handleCancel(iconInput);
-    iconSourcePath = resolve(iconInput.trim());
-  }
-  const iconExt = extname(iconSourcePath).toLowerCase();
-  const iconFileName = iconExt === ".jpeg" ? "icon.jpg" : `icon${iconExt}`;
-  const abilitiesDir = resolve("abilities");
-  const targetDir = join2(abilitiesDir, name);
-  if (existsSync2(targetDir)) {
-    error(`Directory "abilities/${name}" already exists.`);
-    process.exit(1);
-  }
-  const confirmed = await p.confirm({
-    message: `Create ability "${name}" with ${hotwords.length} trigger word(s)?`
-  });
-  handleCancel(confirmed);
-  if (!confirmed) {
-    p.cancel("Aborted.");
-    process.exit(0);
-  }
-  const s = p.spinner();
-  s.start("Generating ability files...");
-  mkdirSync(targetDir, { recursive: true });
-  const className = toClassName(name);
-  const displayName = name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
-  const vars = {
-    CLASS_NAME: className,
-    UNIQUE_NAME: name,
-    DISPLAY_NAME: displayName,
-    DESCRIPTION: description,
-    CATEGORY: category,
-    HOTWORDS: JSON.stringify(hotwords),
-    HOTWORD_LIST: hotwords.length > 0 ? hotwords.map((h) => `- "${h}"`).join("\n") : "_None (daemon)_"
-  };
-  const resolvedTemplate = templateType;
-  const files = getFileList(resolvedTemplate);
-  for (const file of files) {
-    const content = applyTemplate(getTemplate(resolvedTemplate, file), vars);
-    writeFileSync(join2(targetDir, file), content, "utf8");
-  }
-  copyFileSync(iconSourcePath, join2(targetDir, iconFileName));
-  s.stop("Files generated.");
-  registerAbility(name, targetDir);
-  const result = validateAbility(targetDir);
-  if (result.passed) {
-    success("Validation passed.");
-  } else {
-    for (const issue of result.errors) {
-      error(`${issue.file ? `[${issue.file}] ` : ""}${issue.message}`);
-    }
-  }
-  for (const w of result.warnings) {
-    warn(`${w.file ? `[${w.file}] ` : ""}${w.message}`);
-  }
-  p.note(`cd abilities/${name}
-openhome deploy`, "Next steps");
-  p.outro(`Ability "${name}" is ready!`);
-}
+    // ── READWRITE ────────────────────────────────────────────────────────
+    readwrite: {
+      "main.py": `import json
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        reply = await self.capability_worker.run_io_loop(
+            "What would you like me to remember?"
+        )
+
+        # Read existing notes or start fresh
+        if self.capability_worker.check_if_file_exists("notes.json", temp=False):
+            raw = self.capability_worker.read_file("notes.json", temp=False)
+            notes = json.loads(raw)
+        else:
+            notes = []
+
+        notes.append(reply.strip())
+        self.capability_worker.write_file(
+            "notes.json",
+            json.dumps(notes, indent=2),
+            temp=False,
+            mode="w",
+        )
 
-// src/commands/deploy.ts
-import { resolve as resolve2, join as join3, basename as basename2, extname as extname2 } from "path";
-import {
-  readFileSync as readFileSync2,
-  writeFileSync as writeFileSync2,
-  mkdirSync as mkdirSync2,
-  existsSync as existsSync3,
-  readdirSync as readdirSync3
-} from "fs";
-import { homedir as homedir2 } from "os";
+        await self.capability_worker.speak(
+            f"Got it! I now have {len(notes)} note{'s' if len(notes) != 1 else ''} saved."
+        )
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── LOCAL ────────────────────────────────────────────────────────────
+    local: {
+      "main.py": `from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
 
-// src/util/zip.ts
-import archiver from "archiver";
-import { createWriteStream } from "fs";
-import { Writable } from "stream";
-async function createAbilityZip(dirPath) {
-  return new Promise((resolve5, reject) => {
-    const chunks = [];
-    const writable = new Writable({
-      write(chunk, _encoding, callback) {
-        chunks.push(chunk);
-        callback();
-      }
-    });
-    writable.on("finish", () => {
-      resolve5(Buffer.concat(chunks));
-    });
-    writable.on("error", reject);
-    const archive = archiver("zip", { zlib: { level: 9 } });
-    archive.on("error", reject);
-    archive.pipe(writable);
-    archive.glob("**/*", {
-      cwd: dirPath,
-      ignore: [
-        "**/__pycache__/**",
-        "**/*.pyc",
-        "**/.git/**",
-        "**/.env",
-        "**/.env.*",
-        "**/secrets.*",
-        "**/*.key",
-        "**/*.pem"
-      ]
-    });
-    archive.finalize().catch(reject);
-  });
-}
 
-// src/api/mock-client.ts
-var MOCK_PERSONALITIES = [
-  { id: "pers_alice", name: "Alice", description: "Friendly assistant" },
-  { id: "pers_bob", name: "Bob", description: "Technical expert" },
-  { id: "pers_cara", name: "Cara", description: "Creative companion" }
-];
-var MOCK_ABILITIES = [
-  {
-    ability_id: "abl_weather_001",
-    unique_name: "weather-check",
-    display_name: "Weather Check",
-    version: 3,
-    status: "active",
-    personality_ids: ["pers_alice", "pers_bob"],
-    created_at: "2026-01-10T12:00:00Z",
-    updated_at: "2026-03-01T09:30:00Z"
-  },
-  {
-    ability_id: "abl_timer_002",
-    unique_name: "pomodoro-timer",
-    display_name: "Pomodoro Timer",
-    version: 1,
-    status: "processing",
-    personality_ids: ["pers_cara"],
-    created_at: "2026-03-18T08:00:00Z",
-    updated_at: "2026-03-18T08:05:00Z"
-  },
-  {
-    ability_id: "abl_news_003",
-    unique_name: "news-briefing",
-    display_name: "News Briefing",
-    version: 2,
-    status: "failed",
-    personality_ids: [],
-    created_at: "2026-02-20T14:00:00Z",
-    updated_at: "2026-02-21T10:00:00Z"
-  }
-];
-var MockApiClient = class {
-  async getPersonalities() {
-    return Promise.resolve(MOCK_PERSONALITIES);
-  }
-  async uploadAbility(_zipBuffer, _imageBuffer, _imageName, _metadata) {
-    return Promise.resolve({
-      ability_id: `abl_mock_${Date.now()}`,
-      unique_name: "mock-ability",
-      version: 1,
-      status: "processing",
-      validation_errors: [],
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      message: "[MOCK] Ability uploaded successfully and is being processed."
-    });
-  }
-  async listAbilities() {
-    return Promise.resolve({ abilities: MOCK_ABILITIES });
-  }
-  async verifyApiKey(_apiKey) {
-    return Promise.resolve({
-      valid: true,
-      message: "[MOCK] API key is valid."
-    });
-  }
-  async deleteCapability(id) {
-    return Promise.resolve({
-      message: `[MOCK] Capability ${id} deleted successfully.`
-    });
-  }
-  async toggleCapability(id, enabled) {
-    return Promise.resolve({
-      enabled,
-      message: `[MOCK] Capability ${id} ${enabled ? "enabled" : "disabled"}.`
-    });
-  }
-  async assignCapabilities(personalityId, capabilityIds) {
-    return Promise.resolve({
-      message: `[MOCK] Agent ${personalityId} updated with ${capabilityIds.length} capability(s).`
-    });
-  }
-  async getAbility(id) {
-    const found = MOCK_ABILITIES.find(
-      (a) => a.ability_id === id || a.unique_name === id
-    );
-    const base = found ?? MOCK_ABILITIES[0];
-    return Promise.resolve({
-      ...base,
-      validation_errors: base.status === "failed" ? ["Missing resume_normal_flow() call in main.py"] : [],
-      deploy_history: [
-        {
-          version: base.version,
-          status: base.status === "active" ? "success" : "failed",
-          timestamp: base.updated_at,
-          message: base.status === "active" ? "Deployed successfully" : "Validation failed"
-        },
-        ...base.version > 1 ? [
-          {
-            version: base.version - 1,
-            status: "success",
-            timestamp: base.created_at,
-            message: "Deployed successfully"
-          }
-        ] : []
-      ]
-    });
-  }
-};
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
 
-// src/commands/deploy.ts
-var IMAGE_EXTENSIONS = ["png", "jpg", "jpeg"];
-var ICON_NAMES = IMAGE_EXTENSIONS.flatMap((ext) => [
-  `icon.${ext}`,
-  `image.${ext}`,
-  `logo.${ext}`
-]);
-function findIcon(dir) {
-  for (const name of ICON_NAMES) {
-    const p2 = join3(dir, name);
-    if (existsSync3(p2)) return p2;
-  }
-  return null;
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        reply = await self.capability_worker.run_io_loop(
+            "What would you like me to do on your device?"
+        )
+
+        # Use text_to_text to interpret the command
+        response = self.capability_worker.text_to_text_response(
+            f"The user wants to: {reply}. Generate a helpful response.",
+            self.capability_worker.get_full_message_history(),
+        )
+
+        # Send action to DevKit hardware if connected
+        self.capability_worker.send_devkit_action({
+            "type": "command",
+            "payload": reply.strip(),
+        })
+
+        await self.capability_worker.speak(response)
+        self.capability_worker.resume_normal_flow()
+`
+    },
+    // ── OPENCLAW ─────────────────────────────────────────────────────────
+    openclaw: {
+      "main.py": `import requests
+from src.agent.capability import MatchingCapability
+from src.main import AgentWorker
+from src.agent.capability_worker import CapabilityWorker
+
+
+class {{CLASS_NAME}}(MatchingCapability):
+    worker: AgentWorker = None
+    capability_worker: CapabilityWorker = None
+
+    @classmethod
+    def register_capability(cls) -> "MatchingCapability":
+        # {{register_capability}}
+        pass
+
+    def call(self, worker: AgentWorker):
+        self.worker = worker
+        self.capability_worker = CapabilityWorker(self.worker)
+        self.worker.session_tasks.create(self.run())
+
+    async def run(self):
+        reply = await self.capability_worker.run_io_loop(
+            "What would you like me to handle?"
+        )
+
+        gateway_url = self.capability_worker.get_single_key("openclaw_gateway_url")
+        gateway_token = self.capability_worker.get_single_key("openclaw_gateway_token")
+
+        if not gateway_url or not gateway_token:
+            await self.capability_worker.speak(
+                "OpenClaw gateway is not configured. Add openclaw_gateway_url and openclaw_gateway_token as secrets."
+            )
+            self.capability_worker.resume_normal_flow()
+            return
+
+        try:
+            resp = requests.post(
+                f"{gateway_url}/v1/chat",
+                headers={
+                    "Authorization": f"Bearer {gateway_token}",
+                    "Content-Type": "application/json",
+                },
+                json={"message": reply.strip()},
+                timeout=30,
+            )
+            data = resp.json()
+            answer = data.get("reply", data.get("response", "No response from OpenClaw."))
+            await self.capability_worker.speak(answer)
+        except Exception as e:
+            self.worker.editor_logging_handler.error(f"OpenClaw error: {e}")
+            await self.capability_worker.speak("Sorry, I couldn't reach OpenClaw.")
+
+        self.capability_worker.resume_normal_flow()
+`
+    }
+  };
+  return templates[templateType]?.[file] ?? "";
 }
-async function resolveAbilityDir(pathArg) {
-  if (pathArg && pathArg !== ".") {
-    return resolve2(pathArg);
-  }
-  const tracked = getTrackedAbilities();
-  const cwd = process.cwd();
-  const cwdIsAbility = existsSync3(resolve2(cwd, "config.json"));
-  if (cwdIsAbility) {
-    info(`Detected ability in current directory`);
-    return cwd;
+function applyTemplate(content, vars) {
+  let result = content;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
   }
-  const options = [];
-  for (const a of tracked) {
-    const home = homedir2();
-    options.push({
-      value: a.path,
-      label: a.name,
-      hint: a.path.startsWith(home) ? `~${a.path.slice(home.length)}` : a.path
-    });
+  return result;
+}
+function getFileList(templateType) {
+  const base = ["__init__.py", "README.md", "config.json"];
+  if (templateType === "background") {
+    return ["main.py", "background.py", ...base];
   }
-  if (options.length === 1) {
-    info(`Using ability: ${options[0].label} (${options[0].hint})`);
-    return options[0].value;
+  if (templateType === "alarm") {
+    return ["main.py", "background.py", ...base];
   }
-  if (options.length > 0) {
-    options.push({
-      value: "__custom__",
-      label: "Other...",
-      hint: "Enter a path manually"
-    });
-    const selected = await p.select({
-      message: "Which ability do you want to deploy?",
-      options
-    });
-    handleCancel(selected);
-    if (selected !== "__custom__") {
-      return selected;
-    }
+  return ["main.py", ...base];
+}
+function getTemplateOptions(category) {
+  if (category === "skill") {
+    return [
+      {
+        value: "basic",
+        label: "Basic",
+        hint: "Simple ability with speak + user_response"
+      },
+      {
+        value: "api",
+        label: "API",
+        hint: "Calls an external API using a stored secret"
+      },
+      {
+        value: "loop",
+        label: "Loop (ambient observer)",
+        hint: "Records audio periodically and checks in"
+      },
+      {
+        value: "email",
+        label: "Email",
+        hint: "Sends email via SMTP using stored credentials"
+      },
+      {
+        value: "readwrite",
+        label: "File Storage",
+        hint: "Reads and writes persistent JSON files"
+      },
+      {
+        value: "local",
+        label: "Local (DevKit)",
+        hint: "Executes commands on the local device via DevKit"
+      },
+      {
+        value: "openclaw",
+        label: "OpenClaw",
+        hint: "Forwards requests to the OpenClaw gateway"
+      }
+    ];
   }
-  const pathInput = await p.text({
-    message: "Path to ability directory",
-    placeholder: "./my-ability",
-    validate: (val) => {
-      if (!val || !val.trim()) return "Path is required";
-      if (!existsSync3(resolve2(val.trim(), "config.json"))) {
-        return `No config.json found in "${val.trim()}"`;
+  if (category === "brain") {
+    return [
+      {
+        value: "basic",
+        label: "Basic",
+        hint: "Simple ability with speak + user_response"
+      },
+      {
+        value: "api",
+        label: "API",
+        hint: "Calls an external API using a stored secret"
       }
+    ];
+  }
+  return [
+    {
+      value: "background",
+      label: "Background (continuous)",
+      hint: "Runs a loop from session start, no trigger"
+    },
+    {
+      value: "alarm",
+      label: "Alarm (skill + daemon combo)",
+      hint: "Skill sets an alarm; background.py fires it"
     }
-  });
-  handleCancel(pathInput);
-  return resolve2(pathInput.trim());
+  ];
 }
-async function deployCommand(pathArg, opts = {}) {
-  p.intro("\u{1F680} Deploy ability");
-  const targetDir = await resolveAbilityDir(pathArg);
-  const s = p.spinner();
-  s.start("Validating ability...");
-  const validation = validateAbility(targetDir);
-  if (!validation.passed) {
-    s.stop("Validation failed.");
-    for (const issue of validation.errors) {
-      error(`  ${issue.file ? `[${issue.file}] ` : ""}${issue.message}`);
-    }
-    process.exit(1);
-  }
-  s.stop("Validation passed.");
-  if (validation.warnings.length > 0) {
-    for (const w of validation.warnings) {
-      warn(`  ${w.file ? `[${w.file}] ` : ""}${w.message}`);
+async function initCommand(nameArg) {
+  p.intro("Create a new OpenHome ability");
+  let name;
+  if (nameArg) {
+    name = nameArg.trim();
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+      error(
+        "Invalid name. Use lowercase letters, numbers, and hyphens only. Must start with a letter."
+      );
+      process.exit(1);
     }
-  }
-  const configPath = join3(targetDir, "config.json");
-  let abilityConfig;
-  try {
-    abilityConfig = JSON.parse(
-      readFileSync2(configPath, "utf8")
-    );
-  } catch {
-    error("Could not read config.json");
-    process.exit(1);
-  }
-  const uniqueName = abilityConfig.unique_name;
-  const hotwords = abilityConfig.matching_hotwords ?? [];
-  let description = abilityConfig.description?.trim();
-  if (!description) {
-    const descInput = await p.text({
-      message: "Ability description (required for marketplace)",
-      placeholder: "A fun ability that does something cool",
+  } else {
+    const nameInput = await p.text({
+      message: "What should your ability be called?",
+      placeholder: "my-cool-ability",
       validate: (val) => {
-        if (!val || !val.trim()) return "Description is required";
+        if (!val || !val.trim()) return "Name is required";
+        if (!/^[a-z][a-z0-9-]*$/.test(val.trim()))
+          return "Use lowercase letters, numbers, and hyphens only. Must start with a letter.";
       }
     });
-    handleCancel(descInput);
-    description = descInput.trim();
-  }
-  let category = abilityConfig.category;
-  if (!category || !["skill", "brain", "daemon"].includes(category)) {
-    const catChoice = await p.select({
-      message: "Ability category",
-      options: [
-        { value: "skill", label: "Skill", hint: "User-triggered" },
-        { value: "brain", label: "Brain Skill", hint: "Auto-triggered" },
-        {
-          value: "daemon",
-          label: "Background Daemon",
-          hint: "Runs continuously"
-        }
-      ]
-    });
-    handleCancel(catChoice);
-    category = catChoice;
+    handleCancel(nameInput);
+    name = nameInput.trim();
   }
-  let imagePath = findIcon(targetDir);
-  if (imagePath) {
-    info(`Found icon: ${basename2(imagePath)}`);
-  } else {
-    const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
-    const home = homedir2();
-    const scanDirs = [
-      .../* @__PURE__ */ new Set([
-        process.cwd(),
-        targetDir,
-        join3(home, "Desktop"),
-        join3(home, "Downloads"),
-        join3(home, "Pictures"),
-        join3(home, "Images"),
-        join3(home, ".openhome", "icons")
-      ])
-    ];
-    const foundImages = [];
-    for (const dir of scanDirs) {
-      if (!existsSync3(dir)) continue;
-      try {
-        for (const file of readdirSync3(dir)) {
-          if (IMAGE_EXTS.has(extname2(file).toLowerCase())) {
-            const full = join3(dir, file);
-            const shortDir = dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
-            foundImages.push({
-              path: full,
-              label: `${file}  (${shortDir})`
-            });
-          }
-        }
-      } catch {
+  const category = await p.select({
+    message: "What type of ability?",
+    options: [
+      {
+        value: "skill",
+        label: "Skill",
+        hint: "User-triggered, runs on demand (most common)"
+      },
+      {
+        value: "brain",
+        label: "Brain Skill",
+        hint: "Auto-triggered by the agent's intelligence"
+      },
+      {
+        value: "daemon",
+        label: "Background Daemon",
+        hint: "Runs continuously from session start"
+      }
+    ]
+  });
+  handleCancel(category);
+  const descInput = await p.text({
+    message: "Short description for the marketplace",
+    placeholder: "A fun ability that checks the weather",
+    validate: (val) => {
+      if (!val || !val.trim()) return "Description is required";
+    }
+  });
+  handleCancel(descInput);
+  const description = descInput.trim();
+  const templateOptions = getTemplateOptions(category);
+  const templateType = await p.select({
+    message: "Choose a template",
+    options: templateOptions
+  });
+  handleCancel(templateType);
+  const hotwordInput = await p.text({
+    message: DAEMON_TEMPLATES.has(templateType) ? "Trigger words (comma-separated, or leave empty for daemons)" : "Trigger words (comma-separated)",
+    placeholder: "check weather, weather please",
+    validate: (val) => {
+      if (!DAEMON_TEMPLATES.has(templateType)) {
+        if (!val || !val.trim()) return "At least one trigger word is required";
       }
     }
-    if (foundImages.length > 0) {
-      const imageOptions = [
-        ...foundImages.map((img) => ({ value: img.path, label: img.label })),
-        {
-          value: "__custom__",
-          label: "Other...",
-          hint: "Enter a path manually"
-        },
-        {
-          value: "__skip__",
-          label: "Skip",
-          hint: "Upload without an icon (optional)"
+  });
+  handleCancel(hotwordInput);
+  const hotwords = hotwordInput.split(",").map((h) => h.trim()).filter(Boolean);
+  const IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg"]);
+  const home = homedir2();
+  const candidateDirs = [
+    process.cwd(),
+    join3(home, "Desktop"),
+    join3(home, "Downloads"),
+    join3(home, "Pictures"),
+    join3(home, "Images"),
+    join3(home, ".openhome", "icons")
+  ];
+  if (process.env.USERPROFILE) {
+    candidateDirs.push(
+      join3(process.env.USERPROFILE, "Desktop"),
+      join3(process.env.USERPROFILE, "Downloads"),
+      join3(process.env.USERPROFILE, "Pictures")
+    );
+  }
+  const scanDirs = [...new Set(candidateDirs)];
+  const foundImages = [];
+  for (const dir of scanDirs) {
+    if (!existsSync3(dir)) continue;
+    try {
+      const files2 = readdirSync3(dir);
+      for (const file of files2) {
+        if (IMAGE_EXTS.has(extname2(file).toLowerCase())) {
+          const full = join3(dir, file);
+          const shortDir = dir.startsWith(home) ? `~${dir.slice(home.length)}` : dir;
+          foundImages.push({
+            path: full,
+            label: `${file}  (${shortDir})`
+          });
         }
-      ];
-      const selected = await p.select({
-        message: "Select an icon image (optional)",
-        options: imageOptions
-      });
-      handleCancel(selected);
-      if (selected === "__custom__") {
-        const imgInput = await p.text({
-          message: "Path to icon image",
-          placeholder: "./icon.png",
-          validate: (val) => {
-            if (!val || !val.trim()) return void 0;
-            const resolved = resolve2(val.trim());
-            if (!existsSync3(resolved)) return `File not found: ${val.trim()}`;
-            if (!IMAGE_EXTS.has(extname2(resolved).toLowerCase()))
-              return "Image must be PNG or JPG";
-          }
-        });
-        handleCancel(imgInput);
-        const trimmed = imgInput.trim();
-        if (trimmed) imagePath = resolve2(trimmed);
-      } else if (selected !== "__skip__") {
-        imagePath = selected;
       }
-    } else {
-      const imgInput = await p.text({
-        message: "Path to ability icon image (PNG or JPG, optional \u2014 press Enter to skip)",
+    } catch {
+    }
+  }
+  let iconSourcePath;
+  if (foundImages.length > 0) {
+    const imageOptions = [
+      ...foundImages.map((img) => ({ value: img.path, label: img.label })),
+      { value: "__custom__", label: "Other...", hint: "Enter a path manually" }
+    ];
+    const selected = await p.select({
+      message: "Select an icon image (PNG or JPG for marketplace)",
+      options: imageOptions
+    });
+    handleCancel(selected);
+    if (selected === "__custom__") {
+      const iconInput = await p.text({
+        message: "Path to icon image",
         placeholder: "./icon.png",
         validate: (val) => {
-          if (!val || !val.trim()) return void 0;
+          if (!val || !val.trim()) return "An icon image is required";
           const resolved = resolve2(val.trim());
           if (!existsSync3(resolved)) return `File not found: ${val.trim()}`;
-          if (!IMAGE_EXTS.has(extname2(resolved).toLowerCase()))
-            return "Image must be PNG or JPG";
+          const ext = extname2(resolved).toLowerCase();
+          if (!IMAGE_EXTS.has(ext)) return "Image must be PNG or JPG";
         }
       });
-      handleCancel(imgInput);
-      const trimmed = imgInput.trim();
-      if (trimmed) imagePath = resolve2(trimmed);
+      handleCancel(iconInput);
+      iconSourcePath = resolve2(iconInput.trim());
+    } else {
+      iconSourcePath = selected;
     }
+  } else {
+    const iconInput = await p.text({
+      message: "Path to icon image (PNG or JPG for marketplace)",
+      placeholder: "./icon.png",
+      validate: (val) => {
+        if (!val || !val.trim()) return "An icon image is required";
+        const resolved = resolve2(val.trim());
+        if (!existsSync3(resolved)) return `File not found: ${val.trim()}`;
+        const ext = extname2(resolved).toLowerCase();
+        if (!IMAGE_EXTS.has(ext)) return "Image must be PNG or JPG";
+      }
+    });
+    handleCancel(iconInput);
+    iconSourcePath = resolve2(iconInput.trim());
   }
-  const imageBuffer = imagePath ? readFileSync2(imagePath) : null;
-  const imageName = imagePath ? basename2(imagePath) : null;
-  const personalityId = opts.personality ?? getConfig().default_personality_id;
-  const metadata = {
-    name: uniqueName,
-    description,
-    category,
-    matching_hotwords: hotwords,
-    personality_id: personalityId
-  };
-  if (opts.dryRun) {
-    p.note(
-      [
-        `Directory:   ${targetDir}`,
-        `Name:        ${uniqueName}`,
-        `Description: ${description}`,
-        `Category:    ${category}`,
-        `Image:       ${imageName ?? "(none)"}`,
-        `Hotwords:    ${hotwords.join(", ")}`,
-        `Agent:       ${personalityId ?? "(none set)"}`
-      ].join("\n"),
-      "Dry Run \u2014 would deploy"
-    );
-    p.outro("No changes made.");
-    return;
-  }
-  s.start("Creating ability zip...");
-  let zipBuffer;
-  try {
-    zipBuffer = await createAbilityZip(targetDir);
-    s.stop(`Zip created (${(zipBuffer.length / 1024).toFixed(1)} KB)`);
-  } catch (err) {
-    s.stop("Failed to create zip.");
-    error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-  if (opts.mock) {
-    s.start("Uploading ability (mock)...");
-    const mockClient = new MockApiClient();
-    const result = await mockClient.uploadAbility(
-      zipBuffer,
-      imageBuffer,
-      imageName,
-      metadata
-    );
-    s.stop("Upload complete.");
-    p.note(
-      [
-        `Ability ID: ${result.ability_id}`,
-        `Status:     ${result.status}`,
-        `Message:    ${result.message}`
-      ].join("\n"),
-      "Mock Deploy Result"
-    );
-    p.outro("Mock deploy complete.");
-    return;
-  }
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    error("Not authenticated. Run: openhome login");
+  const iconExt = extname2(iconSourcePath).toLowerCase();
+  const iconFileName = iconExt === ".jpeg" ? "icon.jpg" : `icon${iconExt}`;
+  const abilitiesDir = resolve2("abilities");
+  const targetDir = join3(abilitiesDir, name);
+  if (existsSync3(targetDir)) {
+    error(`Directory "abilities/${name}" already exists.`);
     process.exit(1);
   }
   const confirmed = await p.confirm({
-    message: `Deploy "${uniqueName}" to OpenHome?`
+    message: `Create ability "${name}" with ${hotwords.length} trigger word(s)?`
   });
   handleCancel(confirmed);
   if (!confirmed) {
     p.cancel("Aborted.");
     process.exit(0);
   }
-  s.start("Uploading ability...");
-  try {
-    const client = new ApiClient(apiKey, getConfig().api_base_url);
-    const result = await client.uploadAbility(
-      zipBuffer,
-      imageBuffer,
-      imageName,
-      metadata
-    );
-    s.stop("Upload complete.");
-    p.note(
-      [
-        `Ability ID: ${result.ability_id}`,
-        `Version:    ${result.version}`,
-        `Status:     ${result.status}`,
-        result.message ? `Message:    ${result.message}` : ""
-      ].filter(Boolean).join("\n"),
-      "Deploy Result"
-    );
-    p.outro("Deployed successfully! \u{1F389}");
-  } catch (err) {
-    s.stop("Upload failed.");
-    if (err instanceof NotImplementedError) {
-      warn("This API endpoint is not yet available on the OpenHome server.");
-      const outDir = join3(homedir2(), ".openhome");
-      mkdirSync2(outDir, { recursive: true });
-      const outPath = join3(outDir, "last-deploy.zip");
-      writeFileSync2(outPath, zipBuffer);
-      p.note(
-        [
-          `Your ability was validated and zipped successfully.`,
-          `Zip saved to: ${outPath}`,
-          ``,
-          `Upload manually at https://app.openhome.com`
-        ].join("\n"),
-        "API Not Available Yet"
-      );
-      p.outro("Zip ready for manual upload.");
-      return;
+  const s = p.spinner();
+  s.start("Generating ability files...");
+  mkdirSync2(targetDir, { recursive: true });
+  const className = toClassName(name);
+  const displayName = name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+  const vars = {
+    CLASS_NAME: className,
+    UNIQUE_NAME: name,
+    DISPLAY_NAME: displayName,
+    DESCRIPTION: description,
+    CATEGORY: category,
+    HOTWORDS: JSON.stringify(hotwords),
+    HOTWORD_LIST: hotwords.length > 0 ? hotwords.map((h) => `- "${h}"`).join("\n") : "_None (daemon)_"
+  };
+  const resolvedTemplate = templateType;
+  const files = getFileList(resolvedTemplate);
+  for (const file of files) {
+    const content = applyTemplate(getTemplate(resolvedTemplate, file), vars);
+    writeFileSync2(join3(targetDir, file), content, "utf8");
+  }
+  copyFileSync(iconSourcePath, join3(targetDir, iconFileName));
+  s.stop("Files generated.");
+  registerAbility(name, targetDir);
+  const result = validateAbility(targetDir);
+  if (result.passed) {
+    success("Validation passed.");
+  } else {
+    for (const issue of result.errors) {
+      error(`${issue.file ? `[${issue.file}] ` : ""}${issue.message}`);
     }
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.toLowerCase().includes("same name")) {
-      error(`An ability named "${uniqueName}" already exists.`);
-      warn(
-        `To update it, delete it first with: openhome delete
-Or rename it in config.json and redeploy.`
-      );
-    } else {
-      error(`Deploy failed: ${msg}`);
+  }
+  for (const w of result.warnings) {
+    warn(`${w.file ? `[${w.file}] ` : ""}${w.message}`);
+  }
+  if (result.passed) {
+    const deployNow = await p.confirm({
+      message: "Deploy to OpenHome now?",
+      initialValue: true
+    });
+    handleCancel(deployNow);
+    if (deployNow) {
+      await deployCommand(targetDir);
+      return;
     }
-    process.exit(1);
   }
+  p.outro(`Ability "${name}" is ready! Run: openhome deploy`);
 }
 
 // src/commands/delete.ts
@@ -1775,12 +1842,13 @@ async function deleteCommand(abilityArg, opts = {}) {
   if (opts.mock) {
     client = new MockApiClient();
   } else {
-    const apiKey = getApiKey();
-    if (!apiKey) {
+    const apiKey = getApiKey() ?? "";
+    const jwt = getJwt2() ?? void 0;
+    if (!apiKey && !jwt) {
       error("Not authenticated. Run: openhome login");
       process.exit(1);
     }
-    client = new ApiClient(apiKey, getConfig().api_base_url);
+    client = new ApiClient(apiKey, getConfig().api_base_url, jwt);
   }
   const s = p.spinner();
   s.start("Fetching abilities...");
@@ -1857,12 +1925,13 @@ async function toggleCommand(abilityArg, opts = {}) {
   if (opts.mock) {
     client = new MockApiClient();
   } else {
-    const apiKey = getApiKey();
-    if (!apiKey) {
+    const apiKey = getApiKey() ?? "";
+    const jwt = getJwt2() ?? void 0;
+    if (!apiKey && !jwt) {
       error("Not authenticated. Run: openhome login");
       process.exit(1);
     }
-    client = new ApiClient(apiKey, getConfig().api_base_url);
+    client = new ApiClient(apiKey, getConfig().api_base_url, jwt);
   }
   const s = p.spinner();
   s.start("Fetching abilities...");
@@ -1949,12 +2018,13 @@ async function assignCommand(opts = {}) {
   if (opts.mock) {
     client = new MockApiClient();
   } else {
-    const apiKey = getApiKey();
-    if (!apiKey) {
+    const apiKey = getApiKey() ?? "";
+    const jwt = getJwt2() ?? void 0;
+    if (!apiKey && !jwt) {
       error("Not authenticated. Run: openhome login");
       process.exit(1);
     }
-    client = new ApiClient(apiKey, getConfig().api_base_url);
+    client = new ApiClient(apiKey, getConfig().api_base_url, jwt);
   }
   const s = p.spinner();
   s.start("Fetching agents and abilities...");
@@ -2051,12 +2121,13 @@ async function listCommand(opts = {}) {
   if (opts.mock) {
     client = new MockApiClient();
   } else {
-    const apiKey = getApiKey();
-    if (!apiKey) {
+    const apiKey = getApiKey() ?? "";
+    const jwt = getJwt2() ?? void 0;
+    if (!apiKey && !jwt) {
       error("Not authenticated. Run: openhome login");
       process.exit(1);
     }
-    client = new ApiClient(apiKey, getConfig().api_base_url);
+    client = new ApiClient(apiKey, getConfig().api_base_url, jwt);
   }
   const s = p.spinner();
   s.start("Fetching abilities...");
@@ -2170,12 +2241,13 @@ async function statusCommand(abilityArg, opts = {}) {
   if (opts.mock) {
     client = new MockApiClient();
   } else {
-    const apiKey = getApiKey();
-    if (!apiKey) {
+    const apiKey = getApiKey() ?? "";
+    const jwt = getJwt() ?? void 0;
+    if (!apiKey && !jwt) {
       error("Not authenticated. Run: openhome login");
       process.exit(1);
     }
-    client = new ApiClient(apiKey, getConfig().api_base_url);
+    client = new ApiClient(apiKey, getConfig().api_base_url, jwt);
   }
   const s = p.spinner();
   s.start("Fetching status...");
@@ -2977,7 +3049,7 @@ try {
 } catch {
 }
 async function ensureLoggedIn() {
-  const { getApiKey: getApiKey2 } = await import("./store-DR7EKQ5T.js");
+  const { getApiKey: getApiKey2 } = await import("./store-USDMWKXY.js");
   const key = getApiKey2();
   if (!key) {
     await loginCommand();
@@ -2995,12 +3067,7 @@ async function interactiveMenu() {
         {
           value: "init",
           label: "\u2728  Create Ability",
-          hint: "Scaffold a new ability from templates"
-        },
-        {
-          value: "deploy",
-          label: "\u{1F680}  Deploy",
-          hint: "Upload ability to OpenHome"
+          hint: "Scaffold and deploy a new ability"
         },
         {
           value: "chat",
@@ -3070,9 +3137,6 @@ async function interactiveMenu() {
       case "init":
         await initCommand();
         break;
-      case "deploy":
-        await deployCommand();
-        break;
       case "chat":
         await chatCommand();
         break;