@wrongstack/core 0.9.1 → 0.9.7

package/dist/index.js

@@ -56,8 +56,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat8 = await fsp2.stat(targetPath);
-      mode = stat8.mode & 511;
+      const stat9 = await fsp2.stat(targetPath);
+      mode = stat9.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -3916,6 +3916,7 @@ function resolveWstackPaths(opts) {
     secretsKey: path6.join(globalRoot, ".key"),
     globalMemory: path6.join(globalRoot, "memory.md"),
     globalSkills: path6.join(globalRoot, "skills"),
+    globalPrompts: path6.join(globalRoot, "prompts"),
     cacheDir: path6.join(globalRoot, "cache"),
     modelsCache: path6.join(globalRoot, "cache", "models.dev.json"),
     historyFile: path6.join(globalRoot, "history"),
@@ -3935,7 +3936,8 @@ function resolveWstackPaths(opts) {
     projectTaskGraphs: path6.join(projectDir, "task-graphs"),
     projectSddSession: path6.join(projectDir, "sdd-session.json"),
     projectPlan: path6.join(projectDir, "plan.json"),
-    projectAutophase: path6.join(projectDir, "autophase")
+    projectAutophase: path6.join(projectDir, "autophase"),
+    syncConfig: path6.join(globalRoot, "sync.json")
   };
 }
 
@@ -4034,11 +4036,11 @@ function validateAgainstSchema(value, schema) {
   walk2(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk2(value, schema, path28, errors) {
+function walk2(value, schema, path31, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path28 || "<root>",
+        path: path31 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -4047,7 +4049,7 @@ function walk2(value, schema, path28, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path28 || "<root>",
+        path: path31 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -4057,19 +4059,19 @@ function walk2(value, schema, path28, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path28, req), message: "required property missing" });
+        errors.push({ path: joinPath(path31, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk2(obj[key], subSchema, joinPath(path28, key), errors);
+          walk2(obj[key], subSchema, joinPath(path31, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk2(item, schema.items, `${path28}[${i}]`, errors));
+    value.forEach((item, i) => walk2(item, schema.items, `${path31}[${i}]`, errors));
   }
 }
 function checkType(value, type) {
@@ -4248,8 +4250,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat8 = await fsp2.stat(full);
-      const summary = await this.summarize(id, stat8.mtime.toISOString());
+      const stat9 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat9.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -8365,8 +8367,8 @@ ${recentJournal}` : "No prior iterations.",
       await saveGoal(this.goalPath, abandoned);
     }
     try {
-      const { unlink: unlink12 } = await import('fs/promises');
-      await unlink12(this.goalPath);
+      const { unlink: unlink13 } = await import('fs/promises');
+      await unlink13(this.goalPath);
     } catch {
     }
     this.opts.onEternalStop?.();
@@ -14347,8 +14349,8 @@ async function loadProjectModes(modesDir) {
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
       const filePath = path6.join(modesDir, entry);
-      const stat8 = await fsp2.stat(filePath);
-      if (!stat8.isFile()) continue;
+      const stat9 = await fsp2.stat(filePath);
+      if (!stat9.isFile()) continue;
       const content = await fsp2.readFile(filePath, "utf8");
       const id = path6.basename(entry, path6.extname(entry));
       modes.push({
@@ -15622,9 +15624,9 @@ var AISpecBuilder = class {
     if (!this.sessionPath) return;
     try {
       const fsp18 = await import('fs/promises');
-      const path28 = await import('path');
+      const path31 = await import('path');
       const { atomicWrite: atomicWrite2 } = await Promise.resolve().then(() => (init_atomic_write(), atomic_write_exports));
-      await fsp18.mkdir(path28.dirname(this.sessionPath), { recursive: true });
+      await fsp18.mkdir(path31.dirname(this.sessionPath), { recursive: true });
       await atomicWrite2(this.sessionPath, JSON.stringify(this.session, null, 2));
     } catch {
     }
@@ -16334,15 +16336,15 @@ function computeCriticalPath(graph, topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path28 = [];
+  const path31 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path28.unshift(current);
+    path31.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path28;
+  return path31;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -17322,7 +17324,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path28 = opts.path ?? "/metrics";
+  const path31 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -17332,7 +17334,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path28) {
+    if (url === path31) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -17396,7 +17398,7 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path28}`,
+    url: `${protocol}://${host}:${boundPort}${path31}`,
     close: () => new Promise((resolve9, reject) => {
       server.close((err) => err ? reject(err) : resolve9());
     })
@@ -18243,10 +18245,10 @@ var SkillInstaller = class {
           if (!resolved.startsWith(path6.resolve(destDir))) {
             throw new Error(`Path traversal detected in skill file: ${file}`);
           }
-          const stat8 = await fsp2.stat(srcPath);
-          if (stat8.size > MAX_SKILL_FILE_SIZE) {
+          const stat9 = await fsp2.stat(srcPath);
+          if (stat9.size > MAX_SKILL_FILE_SIZE) {
             throw new Error(
-              `Skill file "${file}" is too large (${(stat8.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
+              `Skill file "${file}" is too large (${(stat9.size / 1024).toFixed(1)}KB). Max: ${MAX_SKILL_FILE_SIZE / 1024}KB`
             );
           }
           await fsp2.mkdir(path6.dirname(destPath), { recursive: true });
@@ -18654,6 +18656,356 @@ async function revertSnapshots(snapshots, projectRoot) {
   }
   return { revertedFiles, errors };
 }
+
+// src/storage/prompt-store.ts
+init_atomic_write();
+var DefaultPromptStore = class {
+  dir;
+  constructor(paths) {
+    this.dir = paths.globalPrompts;
+  }
+  async list() {
+    await ensureDir(this.dir);
+    let entries = [];
+    try {
+      const files = await fsp2.readdir(this.dir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const raw = JSON.parse(
+            await fsp2.readFile(path6.join(this.dir, file), "utf8")
+          );
+          entries.push(raw.entry);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return entries.sort(
+      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+  async get(id) {
+    const file = path6.join(this.dir, `${id}.json`);
+    try {
+      const raw = JSON.parse(await fsp2.readFile(file, "utf8"));
+      return raw.entry;
+    } catch {
+      return null;
+    }
+  }
+  async save(entry) {
+    await ensureDir(this.dir);
+    const file = path6.join(this.dir, `${entry.id}.json`);
+    const raw = { version: 1, entry };
+    await atomicWrite(file, JSON.stringify(raw, null, 2));
+  }
+  async delete(id) {
+    const file = path6.join(this.dir, `${id}.json`);
+    try {
+      await fsp2.unlink(file);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async find(query) {
+    const all = await this.list();
+    const lower = query.toLowerCase();
+    return all.filter(
+      (e) => e.title.toLowerCase().includes(lower) || e.content.toLowerCase().includes(lower) || e.tags.some((t2) => t2.toLowerCase().includes(lower))
+    );
+  }
+  /** Create a new entry and return it. Does NOT persist — call save() afterwards. */
+  createNew(title, content, tags = []) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      id: randomUUID().slice(0, 8),
+      title,
+      content,
+      tags,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+};
+var ALL_SYNC_CATEGORIES = ["settings", "skills", "prompts", "memory", "history"];
+var CloudSync = class {
+  constructor(paths, getConfig, setConfig) {
+    this.paths = paths;
+    this.getConfig = getConfig;
+    this.setConfig = setConfig;
+    this.statePath = path6.join(paths.globalRoot, "sync-state.json");
+  }
+  paths;
+  getConfig;
+  setConfig;
+  statePath;
+  state = null;
+  // ── Public API ─────────────────────────────────────────────────────
+  async status() {
+    const cfg = this.getConfig();
+    if (!cfg?.enabled) {
+      return "CloudSync: disabled. Run `/sync enable` to activate.";
+    }
+    const last = this.state?.lastSyncedAt;
+    const since = last ? timeAgo(last) : "never";
+    return [
+      `CloudSync: enabled`,
+      `  repo:       ${cfg.repo}`,
+      `  categories: ${cfg.categories.join(", ")}`,
+      `  last sync:  ${since}`
+    ].join("\n");
+  }
+  async enable(_repo, _categories) {
+    return "Enable via /sync enable.";
+  }
+  async disable() {
+    const cfg = this.getConfig();
+    if (!cfg) return "CloudSync is not configured.";
+    const next = { ...cfg, enabled: false };
+    await this.setConfig(next);
+    return "CloudSync disabled. Local data kept.";
+  }
+  async push(token) {
+    const cfg = this.getConfig();
+    if (!cfg?.enabled) return { ok: false, action: "push", categories: [], message: "Not enabled." };
+    const parts = cfg.repo.split("/");
+    const owner = parts[0];
+    const repoName = parts[1];
+    const branch = "main";
+    const baseTreeSha = this.state?.sha;
+    const { treeEntries, rev } = await this.buildLocalTree(cfg.categories);
+    const newTreeSha = await this.createGitTree(token, owner, repoName, treeEntries, baseTreeSha);
+    const commitSha = await this.createCommit(
+      token,
+      owner,
+      repoName,
+      newTreeSha,
+      baseTreeSha,
+      `Sync ${cfg.categories.join(", ")} \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`
+    );
+    await this.updateRef(token, owner, repoName, branch, commitSha);
+    const syncState = {
+      version: 1,
+      sha: commitSha,
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      localRev: rev
+    };
+    await fsp2.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    this.state = syncState;
+    return {
+      ok: true,
+      action: "push",
+      categories: cfg.categories,
+      committedAt: commitSha,
+      message: `Pushed ${cfg.categories.join(", ")} to ${cfg.repo}. Commit: ${commitSha.slice(0, 7)}`
+    };
+  }
+  async pull(token) {
+    const cfg = this.getConfig();
+    if (!cfg?.enabled) return { ok: false, action: "pull", categories: [], message: "Not enabled." };
+    const pullParts = cfg.repo.split("/");
+    const owner = pullParts[0];
+    const repoName = pullParts[1];
+    const branchData = await this.getRef(token, owner, repoName, "main");
+    const currentSha = branchData.object.sha;
+    const commitData = await this.getCommit(token, owner, repoName, currentSha);
+    const treeSha = commitData.tree.sha;
+    const treeEntries = await this.getTreeEntries(token, owner, repoName, treeSha);
+    for (const entry of treeEntries) {
+      if (entry.type !== "blob") continue;
+      const segments = entry.path.split("/");
+      if (segments[0] !== "data" || !segments[1]) continue;
+      const cat = segments[1];
+      if (!["settings", "skills", "prompts", "memory", "history"].includes(cat)) continue;
+      const localPath = this.categoryToPath(cat);
+      if (!localPath) continue;
+      const rel = segments.slice(2).join("/");
+      const destPath = rel ? path6.join(localPath, rel) : localPath;
+      const blobData = await this.getBlob(token, owner, repoName, entry.sha);
+      await fsp2.mkdir(path6.dirname(destPath), { recursive: true });
+      await fsp2.writeFile(destPath, Buffer.from(blobData, "base64"));
+    }
+    const localRev = await this.hashLocalCategories(cfg.categories);
+    const syncState = {
+      version: 1,
+      sha: currentSha,
+      lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      localRev
+    };
+    await fsp2.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    this.state = syncState;
+    return {
+      ok: true,
+      action: "pull",
+      categories: cfg.categories,
+      committedAt: currentSha,
+      message: `Pulled ${cfg.categories.join(", ")} from ${cfg.repo}. Commit: ${currentSha.slice(0, 7)}`
+    };
+  }
+  async hasLocalChanges() {
+    if (!this.state) return true;
+    const cfg = this.getConfig();
+    if (!cfg) return true;
+    const current = await this.hashLocalCategories(cfg.categories);
+    return current !== this.state.localRev;
+  }
+  async loadState() {
+    try {
+      const raw = await fsp2.readFile(this.statePath, "utf8");
+      this.state = JSON.parse(raw);
+    } catch {
+      this.state = null;
+    }
+  }
+  // ── GitHub API helpers ──────────────────────────────────────────────
+  async githubFetch(token, owner, repo, method, pathSegment, body) {
+    const url = `https://api.github.com/repos/${owner}/${repo}${pathSegment}`;
+    const res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "Content-Type": "application/json"
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const errText = await res.text();
+      throw new Error(`GitHub API ${method} ${pathSegment} failed (${res.status}): ${errText}`);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+  }
+  async getRef(token, owner, repo, ref) {
+    return await this.githubFetch(token, owner, repo, "GET", `/git/refs/heads/${ref}`);
+  }
+  async updateRef(token, owner, repo, ref, sha) {
+    await this.githubFetch(token, owner, repo, "PATCH", `/git/refs/heads/${ref}`, {
+      sha,
+      force: false
+    });
+  }
+  async getCommit(token, owner, repo, sha) {
+    return await this.githubFetch(token, owner, repo, "GET", `/git/commits/${sha}`);
+  }
+  async getTreeEntries(token, owner, repo, treeSha) {
+    return await this.githubFetch(token, owner, repo, "GET", `/git/trees/${treeSha}?recursive=1`);
+  }
+  async createCommit(token, owner, repo, treeSha, parentSha, message = "sync") {
+    const body = { message, tree: treeSha };
+    if (parentSha) body.parents = [parentSha];
+    const result = await this.githubFetch(token, owner, repo, "POST", "/git/commits", body);
+    return result.sha;
+  }
+  async createGitTree(token, owner, repo, entries, baseTreeSha) {
+    const tree = entries.map((e) => ({
+      path: e.path,
+      mode: e.mode,
+      type: "blob",
+      content: e.content
+    }));
+    const body = { tree };
+    if (baseTreeSha) body.base_tree = baseTreeSha;
+    const result = await this.githubFetch(token, owner, repo, "POST", "/git/trees", body);
+    return result.sha;
+  }
+  async getBlob(token, owner, repo, sha) {
+    const result = await this.githubFetch(token, owner, repo, "GET", `/git/blobs/${sha}`);
+    return result.content;
+  }
+  // ── Local file helpers ──────────────────────────────────────────────
+  async buildLocalTree(categories) {
+    const entries = [];
+    const hashes = [];
+    for (const cat of categories) {
+      const localPath = this.categoryToPath(cat);
+      if (!localPath) continue;
+      try {
+        const stat9 = await fsp2.stat(localPath);
+        if (stat9.isDirectory()) {
+          const files = await this.walkDir(localPath, localPath);
+          for (const file of files) {
+            const content = await fsp2.readFile(file, "utf8");
+            const rel = path6.relative(localPath, file).replace(/\\/g, "/");
+            entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
+            hashes.push(content);
+          }
+        } else {
+          const content = await fsp2.readFile(localPath, "utf8");
+          entries.push({ path: `data/${cat}`, content, mode: "100644" });
+          hashes.push(content);
+        }
+      } catch {
+      }
+    }
+    const rev = createHash("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
+    return { treeEntries: entries, rev };
+  }
+  async hashLocalCategories(categories) {
+    const hashes = [];
+    for (const cat of categories) {
+      const localPath = this.categoryToPath(cat);
+      if (!localPath) continue;
+      try {
+        const stat9 = await fsp2.stat(localPath);
+        if (stat9.isDirectory()) {
+          const files = await this.walkDir(localPath, localPath);
+          for (const file of files) {
+            const content = await fsp2.readFile(file);
+            hashes.push(content.toString("base64") + file);
+          }
+        } else {
+          const content = await fsp2.readFile(localPath);
+          hashes.push(content.toString("base64") + localPath);
+        }
+      } catch {
+      }
+    }
+    return createHash("sha256").update(hashes.join("")).digest("hex").slice(0, 12);
+  }
+  categoryToPath(cat) {
+    switch (cat) {
+      case "settings":
+        return this.paths.globalConfig;
+      case "skills":
+        return this.paths.globalSkills;
+      case "prompts":
+        return this.paths.globalPrompts;
+      case "memory":
+        return this.paths.globalMemory;
+      case "history":
+        return this.paths.historyFile;
+      default:
+        return null;
+    }
+  }
+  async walkDir(dir, base) {
+    const results = [];
+    const entries = await fsp2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await this.walkDir(full, base));
+      } else {
+        results.push(full);
+      }
+    }
+    return results;
+  }
+};
+function timeAgo(iso) {
+  const diff = Date.now() - new Date(iso).getTime();
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  const days = Math.floor(hrs / 24);
+  return `${days}d ago`;
+}
 var MATCHERS = {
   pnpmWorkspace: (files) => files.includes("pnpm-workspace.yaml"),
   gradlew: (_files, dirs) => dirs.includes("gradlew"),
@@ -19531,8 +19883,8 @@ var ReportGenerator = class {
     try {
       await stat(this.options.outputDir);
     } catch {
-      const { mkdir: mkdir14 } = await import('fs/promises');
-      await mkdir14(this.options.outputDir, { recursive: true });
+      const { mkdir: mkdir15 } = await import('fs/promises');
+      await mkdir15(this.options.outputDir, { recursive: true });
     }
   }
   generateMarkdown(result) {
@@ -20454,16 +20806,16 @@ Use \`/security report <number>\` to view a specific report.` };
     }
     const index = Number.parseInt(reportId, 10) - 1;
     if (!Number.isNaN(index) && reports[index]) {
-      const { readFile: readFile32 } = await import('fs/promises');
-      const content = await readFile32(join(reportsDir, reports[index]), "utf-8");
+      const { readFile: readFile34 } = await import('fs/promises');
+      const content = await readFile34(join(reportsDir, reports[index]), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
     }
     const match = reports.find((r) => r.includes(reportId));
     if (match) {
-      const { readFile: readFile32 } = await import('fs/promises');
-      const content = await readFile32(join(reportsDir, match), "utf-8");
+      const { readFile: readFile34 } = await import('fs/promises');
+      const content = await readFile34(join(reportsDir, match), "utf-8");
       return { message: `# Security Report
 
 ${content}` };
@@ -22625,8 +22977,8 @@ ${mem}`);
   }
   async dirExists(p) {
     try {
-      const stat8 = await fsp2.stat(p);
-      return stat8.isDirectory();
+      const stat9 = await fsp2.stat(p);
+      return stat9.isDirectory();
     } catch {
       return false;
     }
@@ -22887,39 +23239,55 @@ var ProviderRegistry = class {
 var SlashCommandRegistry = class {
   cmds = /* @__PURE__ */ new Map();
   /**
-   * Register a command. For plugins the `owner` is the plugin name and the
-   * registry auto-prefixes the command name as `owner:name` to prevent
-   * collisions with built-in commands and other plugins.
+   * Register a command.
+   *
+   * Trust tiers, by `owner` and `opts.official`:
+   *
+   *  - **Built-ins** (`owner === 'core'`) and **official plugins**
+   *    (`opts.official === true`, set by the host only for first-party plugins
+   *    loaded from the built-in factory list) claim the **bare** command name
+   *    (`/prompts`). They may override one another — last write wins — so an
+   *    official plugin can replace a built-in. Official plugins are *also*
+   *    reachable under their `owner:name` namespace.
+   *  - **External plugins** (any other `owner`) are isolated under the
+   *    `owner:name` namespace: invocable only as `/owner:cmd`, never by bare
+   *    name, and unable to shadow or override a built-in or official command.
+   *
+   * Officiality is supplied by the host based on the plugin's load source, not
+   * self-declared by the plugin — an external plugin cannot name itself into
+   * the official tier.
    */
-  register(cmd, owner = "core") {
+  register(cmd, owner = "core", opts) {
     const isPlugin = owner !== "core";
-    const fullName = isPlugin ? `${owner}:${cmd.name}` : cmd.name;
-    for (const entry of this.cmds.values()) {
-      if (entry.cmd.name === cmd.name && entry.owner !== owner) {
-        throw new Error(`Slash command "${cmd.name}" already registered by ${entry.owner}`);
+    const official = !isPlugin || opts?.official === true;
+    if (official) {
+      const existing = this.cmds.get(cmd.name);
+      if (existing) {
+        const existingIsOfficialPlugin = existing.official && existing.owner !== "core";
+        if (!isPlugin && existingIsOfficialPlugin) {
+          return;
+        }
+        if (!isPlugin && existing.owner === "core") return;
       }
-    }
-    if (this.cmds.has(fullName)) {
-      if (!isPlugin) return;
-      this.cmds.set(fullName, { cmd, owner });
+      this.cmds.set(cmd.name, { cmd, owner, official });
       for (const a of cmd.aliases ?? []) {
-        this.cmds.set(`${owner}:${a}`, { cmd, owner });
+        this.cmds.set(a, { cmd, owner, official });
       }
-      return;
     }
-    this.cmds.set(fullName, { cmd, owner });
-    for (const a of cmd.aliases ?? []) {
-      this.cmds.set(isPlugin ? `${owner}:${a}` : a, { cmd, owner });
+    if (isPlugin) {
+      this.cmds.set(`${owner}:${cmd.name}`, { cmd, owner, official });
+      for (const a of cmd.aliases ?? []) {
+        this.cmds.set(`${owner}:${a}`, { cmd, owner, official });
+      }
     }
   }
   unregister(name) {
     const entry = this.cmds.get(name);
     if (!entry) return false;
-    for (const a of entry.cmd.aliases ?? []) {
-      const fullAlias = entry.owner !== "core" ? `${entry.owner}:${a}` : a;
-      this.cmds.delete(fullAlias);
+    for (const [key, e] of this.cmds.entries()) {
+      if (e.cmd === entry.cmd) this.cmds.delete(key);
     }
-    return this.cmds.delete(name);
+    return true;
   }
   /**
    * Bulk-register multiple slash commands at once.
@@ -23038,8 +23406,9 @@ var DefaultPluginAPI = class {
     };
     this.mcp = init.mcpRegistry ?? noopMcp;
     const scr = init.slashCommandRegistry;
+    const official = init.official === true;
     this.slashCommands = scr ? {
-      register: (cmd) => scr.register(cmd, owner),
+      register: (cmd) => scr.register(cmd, owner, { official }),
       unregister: (name) => scr.unregister(name),
       get: (name) => scr.get(name),
       list: () => scr.list()
@@ -24927,6 +25296,1054 @@ function assertSafePath(dir, projectRoot) {
   }
 }
 
-export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createMcpControlTool, createMessage, createSecuritySlashCommand, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
+// src/plugins/prompts-plugin.ts
+function createPromptsPlugin(opts) {
+  let store = null;
+  return {
+    name: "wstack-prompts",
+    version: "1.0.0",
+    description: "Personal prompt library with LLM-powered enhancements",
+    apiVersion: "^0.1",
+    capabilities: { slashCommands: true },
+    defaultConfig: {},
+    setup(api) {
+      const rawConfig = api.config;
+      const paths = opts?.paths ?? rawConfig.paths;
+      store = opts?.store ?? (paths ? new DefaultPromptStore(paths) : null);
+      api.slashCommands.register(buildPromptsCommand(store));
+      api.log.info("[prompts] loaded \u2014 /prompts available");
+    },
+    teardown(api) {
+      api.slashCommands.unregister("prompts");
+      api.log.info("[prompts] unloaded");
+    },
+    async health() {
+      return { ok: true, message: "Prompt store accessible" };
+    }
+  };
+}
+function buildPromptsCommand(store) {
+  return {
+    name: "prompts",
+    description: "Manage your prompt library: /prompts [list|view|add|delete|edit|extend]",
+    async run(args, ctx) {
+      if (!store) return { message: "Prompt store not available." };
+      const [verb, ...rest] = args.trim().split(/\s+/);
+      const restJoined = rest.join(" ");
+      switch (verb) {
+        case "":
+        case "list":
+        case "ls": {
+          const entries = await store.list();
+          if (entries.length === 0) {
+            return { message: 'Prompt library empty. Add: /prompts add "title" "content"' };
+          }
+          const lines = entries.map(
+            (e) => `  ${e.title}  ${dim2(e.id)}  ${e.tags.join(", ") || ""}`
+          );
+          return { message: `Prompt library (${entries.length}):
+${lines.join("\n")}
+` };
+        }
+        case "view":
+        case "show": {
+          if (!restJoined) return { message: "Usage: /prompts view <title>" };
+          const matches = await store.find(restJoined);
+          if (matches.length === 0) return { message: `No prompt matching "${restJoined}".` };
+          const entry = matches.find((m) => m.title.toLowerCase() === restJoined.toLowerCase()) ?? matches[0];
+          const tags = entry.tags.length > 0 ? ` [${entry.tags.join(", ")}]` : "";
+          return {
+            message: `# ${entry.title}${tags}
+
+${entry.content}
+
+${dim2(`id: ${entry.id} | created: ${entry.createdAt}`)}`
+          };
+        }
+        case "add":
+        case "new": {
+          const parsed = parseTitleContent(restJoined);
+          if (!parsed.title) return { message: 'Usage: /prompts add "title" "prompt content"' };
+          const entry = store.createNew(parsed.title, parsed.content);
+          await store.save(entry);
+          return { message: `Added prompt "${entry.title}" (${entry.id}).` };
+        }
+        case "delete":
+        case "rm": {
+          if (!restJoined) return { message: "Usage: /prompts delete <title>" };
+          const matches = await store.find(restJoined);
+          if (matches.length === 0) return { message: `No prompt matching "${restJoined}".` };
+          const exact = matches.find((m) => m.title.toLowerCase() === restJoined.toLowerCase()) ?? matches[0];
+          const deleted = await store.delete(exact.id);
+          return { message: deleted ? `Deleted "${exact.title}".` : "Delete failed." };
+        }
+        case "edit":
+        case "update": {
+          const parsed = parseTitleContent(restJoined);
+          if (!parsed.title) return { message: 'Usage: /prompts edit "title" "new content"' };
+          const matches = await store.find(parsed.title);
+          if (matches.length === 0) return { message: `No prompt matching "${parsed.title}".` };
+          const exact = matches.find((m) => m.title.toLowerCase() === parsed.title.toLowerCase()) ?? matches[0];
+          exact.content = parsed.content;
+          exact.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          await store.save(exact);
+          return { message: `Updated "${exact.title}".` };
+        }
+        case "extend": {
+          if (!restJoined) return { message: 'Usage: /prompts extend "title" <instructions>' };
+          const parsed = parseTitleContent(restJoined);
+          if (!parsed.title) return { message: 'Usage: /prompts extend "title" <instructions>' };
+          const matches = await store.find(parsed.title);
+          if (matches.length === 0) return { message: `No prompt matching "${parsed.title}".` };
+          const exact = matches.find((m) => m.title.toLowerCase() === parsed.title.toLowerCase()) ?? matches[0];
+          const prov = ctx.provider;
+          if (!prov?.complete) return { message: "LLM not available. Configure a provider first." };
+          const enhanced = await prov.complete(ctx.model, [
+            "[SYSTEM INSTRUCTIONS]",
+            "You are a prompt engineering assistant. Improve the following prompt by integrating the additional instructions seamlessly. Keep the same tone and format. Return only the improved prompt.",
+            "",
+            `EXISTING PROMPT:
+${exact.content}`,
+            "",
+            `ADDITIONAL INSTRUCTIONS:
+${parsed.content}`,
+            "",
+            "Respond with ONLY the improved prompt, no commentary."
+          ].join("\n"));
+          exact.content = enhanced.trim();
+          exact.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          await store.save(exact);
+          return { message: `Extended "${exact.title}".
+
+${dim2("New content:")}
+${exact.content}` };
+        }
+        default:
+          return {
+            message: `Unknown subcommand "${verb}". Try: list | view | add | delete | edit | extend`
+          };
+      }
+    }
+  };
+}
+function parseTitleContent(args) {
+  const trimmed = args.trim();
+  if (!trimmed) return { title: "", content: "" };
+  const doubleMatch = /^"([^"]+)"\s+"([^"]+)"$/.exec(trimmed) || /^'([^']+)'\s+'([^']+)'$/.exec(trimmed);
+  if (doubleMatch) return { title: doubleMatch[1], content: doubleMatch[2] };
+  const singleMatch = /^'([^']+)'\s+(.+)$/.exec(trimmed);
+  if (singleMatch) return { title: singleMatch[1], content: singleMatch[2] };
+  const firstSpace = trimmed.indexOf(" ");
+  if (firstSpace === -1) return { title: trimmed, content: "" };
+  return { title: trimmed.slice(0, firstSpace), content: trimmed.slice(firstSpace + 1) };
+}
+function dim2(s) {
+  return `\x1B[2m${s}\x1B[0m`;
+}
+
+// src/plugins/sync-plugin.ts
+function createSyncPlugin(opts) {
+  let cloud = null;
+  let configStore;
+  return {
+    name: "wstack-sync",
+    version: "1.0.0",
+    description: "GitHub cloud sync for prompts, skills, settings, memory and history",
+    apiVersion: "^0.1",
+    capabilities: { slashCommands: true },
+    defaultConfig: {},
+    setup(api) {
+      const rawConfig = api.config;
+      const paths = opts?.paths ?? rawConfig.paths;
+      configStore = opts?.configStore ?? rawConfig.configStore;
+      if (!paths || !configStore) {
+        api.log.warn("[sync] paths or configStore not available \u2014 /sync disabled");
+        return;
+      }
+      cloud = new CloudSync(
+        paths,
+        () => {
+          const cfg = configStore.get();
+          return cfg.sync;
+        },
+        async (cfg) => {
+          configStore.update({ sync: cfg });
+        }
+      );
+      void cloud.loadState();
+      api.slashCommands.register(buildSyncCommand(cloud, configStore));
+      api.log.info("[sync] loaded \u2014 /sync available. Run /sync to get started.");
+    },
+    teardown(api) {
+      api.slashCommands.unregister("sync");
+      api.log.info("[sync] unloaded");
+    },
+    async health() {
+      return { ok: true, message: "CloudSync ready" };
+    }
+  };
+}
+function buildSyncCommand(cloud, configStore) {
+  return {
+    name: "sync",
+    description: "Cloud sync: /sync [status|enable|disable|push|pull|categories]",
+    async run(args, _ctx) {
+      const [verb, ...rest] = args.trim().split(/\s+/);
+      const restJoined = rest.join(" ");
+      switch (verb) {
+        case "":
+        case "status": {
+          const msg = await cloud.status();
+          return { message: msg };
+        }
+        case "enable": {
+          const parts = restJoined.trim().split(/\s+/);
+          if (parts.length < 2) {
+            return {
+              message: [
+                "Usage: /sync enable owner/repo TOKEN [cat1 cat2 ...]",
+                "  e.g. /sync enable myname/wrongstack-data ghp_xxx",
+                `  Categories (default: all): ${ALL_SYNC_CATEGORIES.join(", ")}`
+              ].join("\n")
+            };
+          }
+          const [repo, token, ...cats] = parts;
+          if (!repo || !repo.includes("/")) {
+            return { message: 'Invalid repo format. Expected "owner/repo".' };
+          }
+          const syncConfig = {
+            enabled: true,
+            repo,
+            githubToken: token,
+            categories: cats.length > 0 ? cats : ALL_SYNC_CATEGORIES,
+            lastSyncedAt: void 0
+          };
+          configStore.update({ sync: syncConfig });
+          await cloud.loadState();
+          return {
+            message: [
+              `CloudSync enabled for ${repo}`,
+              `  categories: ${syncConfig.categories.join(", ")}`,
+              "",
+              "Run `/sync push` to upload your data to GitHub."
+            ].join("\n")
+          };
+        }
+        case "disable": {
+          const msg = await cloud.disable();
+          return { message: msg };
+        }
+        case "push": {
+          const cfg = configStore.get().sync;
+          if (!cfg?.enabled) return { message: "CloudSync not enabled. Run `/sync enable`." };
+          if (!cfg?.githubToken) return { message: "No GitHub token found. Run `/sync enable owner/repo TOKEN`." };
+          let result;
+          try {
+            result = await cloud.push(cfg.githubToken);
+          } catch (err) {
+            return { message: `Push failed: ${err instanceof Error ? err.message : String(err)}` };
+          }
+          if (result.ok) {
+            configStore.update({
+              sync: { ...cfg, lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          }
+          return { message: result.message };
+        }
+        case "pull": {
+          const cfg = configStore.get().sync;
+          if (!cfg?.enabled) return { message: "CloudSync not enabled. Run `/sync enable`." };
+          if (!cfg?.githubToken) return { message: "No GitHub token. Run `/sync enable owner/repo TOKEN`." };
+          let result;
+          try {
+            result = await cloud.pull(cfg.githubToken);
+          } catch (err) {
+            return { message: `Pull failed: ${err instanceof Error ? err.message : String(err)}` };
+          }
+          if (result.ok) {
+            configStore.update({
+              sync: { ...cfg, lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString() }
+            });
+          }
+          return { message: result.message };
+        }
+        case "categories": {
+          const [action, ...catRest] = restJoined.trim().split(/\s+/);
+          const cfg = configStore.get().sync;
+          if (!cfg?.enabled) return { message: "CloudSync not enabled. Run `/sync enable`." };
+          if (action === "list" || !action) {
+            return {
+              message: [
+                `Synced categories: ${cfg.categories.join(", ")}`,
+                `Available: ${ALL_SYNC_CATEGORIES.join(", ")}`,
+                "Update: /sync categories add <name> | remove <name>"
+              ].join("\n")
+            };
+          }
+          if (action === "add") {
+            const catName = catRest[0];
+            if (!ALL_SYNC_CATEGORIES.includes(catName)) {
+              return { message: `Unknown. Available: ${ALL_SYNC_CATEGORIES.join(", ")}` };
+            }
+            if (cfg.categories.includes(catName)) return { message: `"${catName}" already synced.` };
+            configStore.update({
+              sync: { ...cfg, categories: [...cfg.categories, catName] }
+            });
+            return { message: `Added "${catName}" to sync categories.` };
+          }
+          if (action === "remove") {
+            const catName = catRest[0];
+            if (!cfg.categories.includes(catName)) return { message: `"${catName}" not in sync categories.` };
+            configStore.update({
+              sync: { ...cfg, categories: cfg.categories.filter((c) => c !== catName) }
+            });
+            return { message: `Removed "${catName}" from sync categories.` };
+          }
+          return { message: "Usage: /sync categories list | add <name> | remove <name>" };
+        }
+        default:
+          return {
+            message: [
+              "/sync \u2014 Cloud Sync",
+              "",
+              "  /sync status                    Show current sync status",
+              "  /sync enable owner/repo TOKEN    Enable for a repo (TOKEN = fine-grained PAT)",
+              "  /sync disable                   Disable sync (keeps local data)",
+              "  /sync push                      Upload selected categories",
+              "  /sync pull                      Download from repo",
+              "  /sync categories list|add|remove  Manage synced categories",
+              "",
+              `Categories: ${ALL_SYNC_CATEGORIES.join(", ")}`
+            ].join("\n")
+          };
+      }
+    }
+  };
+}
+function createGitPlugin() {
+  return {
+    name: "wstack-git",
+    version: "1.0.0",
+    description: "Git helpers: /commit (LLM message), /gitcheck, /push",
+    apiVersion: "^0.1",
+    capabilities: { slashCommands: true },
+    defaultConfig: {},
+    setup(api) {
+      api.slashCommands.register(buildCommitCommand());
+      api.slashCommands.register(buildGitcheckCommand());
+      api.slashCommands.register(buildPushCommand());
+      api.log.info("[git] loaded \u2014 /commit, /gitcheck, /push available");
+    },
+    teardown(api) {
+      api.slashCommands.unregister("commit");
+      api.slashCommands.unregister("gitcheck");
+      api.slashCommands.unregister("push");
+      api.log.info("[git] unloaded");
+    },
+    async health() {
+      return { ok: true, message: "git helpers ready" };
+    }
+  };
+}
+async function runGit(args, cwd) {
+  try {
+    return await new Promise((resolve9, reject) => {
+      const child = spawn("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (d) => {
+        stdout += d;
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d;
+      });
+      child.on("error", (err) => {
+        reject(
+          new WrongStackError({
+            message: `Failed to run git: ${err.message}`,
+            code: ERROR_CODES.TOOL_EXECUTION_FAILED,
+            subsystem: "tool",
+            context: { command: "git", args, cwd },
+            cause: err
+          })
+        );
+      });
+      child.on("close", (code) => resolve9({ stdout, stderr, code: code ?? 0 }));
+    });
+  } catch (err) {
+    if (err instanceof WrongStackError) throw err;
+    throw new WrongStackError({
+      message: err instanceof Error ? err.message : String(err),
+      code: ERROR_CODES.TOOL_EXECUTION_FAILED,
+      subsystem: "tool",
+      context: { command: "git", args, cwd },
+      cause: err
+    });
+  }
+}
+async function isGitRepo(cwd) {
+  const result = await runGit(["rev-parse", "--git-dir"], cwd);
+  return result.code === 0;
+}
+async function hasUncommittedChanges(cwd) {
+  const result = await runGit(["status", "--porcelain"], cwd);
+  return result.stdout.trim().length > 0;
+}
+function asLLMProvider(provider) {
+  if (provider && typeof provider.complete === "function") {
+    return provider;
+  }
+  return null;
+}
+async function generateCommitMessageWithLLM(diff, provider, model) {
+  const systemPrompt = "You are a helpful assistant that generates concise, conventional-commit-formatted git commit messages. Analyze the provided diff and output ONLY the commit message (no explanation, no quotes). Format: <type>(<scope>): <short description> \u2014 <type> is one of: feat, fix, docs, style, refactor, test, chore, perf, ci, build, temp. If the diff contains multiple unrelated changes, pick the most important one. Keep the description under 72 characters. Example: feat(cli): add /commit LLM integration";
+  try {
+    const ac = new AbortController();
+    const timeout = setTimeout(() => ac.abort(), 15e3);
+    const resp = await provider.complete(
+      {
+        model,
+        system: [{ type: "text", text: systemPrompt }],
+        messages: [
+          { role: "user", content: [{ type: "text", text: `Here is the git diff:
+
+${diff}` }] }
+        ],
+        maxTokens: 80,
+        temperature: 0.3
+      },
+      { signal: ac.signal }
+    );
+    clearTimeout(timeout);
+    const raw = resp.content;
+    const text = Array.isArray(raw) ? raw[0]?.text ?? "" : typeof raw === "object" && raw !== null ? raw.text ?? "" : String(raw ?? "");
+    const message = text.trim().split("\n")[0] ?? "";
+    if (message.length > 0 && message.length < 200) return message;
+  } catch {
+  }
+  return null;
+}
+function detectCommitType(stats) {
+  const lines = stats.split("\n");
+  const hasTestFiles = lines.some(
+    (l) => l.includes("_test.") || l.includes(".test.") || l.includes(".spec.")
+  );
+  const hasDocs = lines.some(
+    (l) => l.includes("README") || l.includes("CHANGELOG") || l.includes("docs/") || l.includes(".md")
+  );
+  const hasConfig = lines.some(
+    (l) => l.includes("config") || l.includes("tsconfig") || l.includes(".json")
+  );
+  if (hasTestFiles) return "test";
+  if (hasDocs) return "docs";
+  if (hasConfig) return "chore";
+  return "feat";
+}
+async function generateCommitMessageHeuristics(cwd) {
+  const statsResult = await runGit(["diff", "--stat"], cwd);
+  if (statsResult.code !== 0) return "chore: update";
+  const nameResult = await runGit(["diff", "--name-only"], cwd);
+  const files = nameResult.stdout.split("\n").filter(Boolean);
+  const commitType = detectCommitType(statsResult.stdout);
+  let scope = "";
+  if (files.length > 0) {
+    const primary = files[0].split("/")[0];
+    if (primary && primary !== "packages" && primary !== "apps" && primary !== "node_modules") {
+      scope = `(${primary})`;
+    }
+  }
+  if (files.length === 0) return `${commitType}${scope}: update`;
+  if (files.length <= 3) {
+    const summary2 = files.map((f) => f.split("/").pop()).join(", ");
+    return `${commitType}${scope}: ${summary2}`;
+  }
+  const summary = `${files.slice(0, 3).map((f) => f.split("/").pop()).join(", ")} and ${files.length - 3} more`;
+  return `${commitType}${scope}: ${summary}`;
+}
+function buildCommitCommand() {
+  return {
+    name: "commit",
+    description: "Stage all changes and commit with auto-generated message.",
+    aliases: ["gc"],
+    async run(args, ctx) {
+      const cwd = ctx?.cwd ?? process.cwd();
+      if (!await isGitRepo(cwd)) return { message: "Not a git repository." };
+      if (!await hasUncommittedChanges(cwd)) {
+        return { message: "Nothing to commit (working tree clean)." };
+      }
+      const dryRun = args.includes("--dry-run") || args.includes("-n");
+      const noLlm = args.includes("--no-llm");
+      let message = null;
+      const provider = noLlm ? null : asLLMProvider(ctx?.provider);
+      if (provider && ctx?.model) {
+        const diff = (await runGit(["diff"], cwd)).stdout;
+        message = await generateCommitMessageWithLLM(diff, provider, ctx.model);
+      }
+      if (!message) message = await generateCommitMessageHeuristics(cwd);
+      if (dryRun) {
+        return {
+          message: `Would commit:
+
+  ${color.green(message)}
+
+${color.dim("(dry-run \u2014 no actual commit)")}`
+        };
+      }
+      const stageResult = await runGit(["add", "."], cwd);
+      if (stageResult.code !== 0) return { message: `Stage failed: ${stageResult.stderr}` };
+      const commitResult = await runGit(["commit", "-m", message], cwd);
+      if (commitResult.code !== 0) return { message: `Commit failed: ${commitResult.stderr}` };
+      const hash = (await runGit(["rev-parse", "--short", "HEAD"], cwd)).stdout.trim();
+      const hasRemote = (await runGit(["remote"], cwd)).stdout.trim().length > 0;
+      const pushMsg = hasRemote ? `
+
+${color.dim("Tip: Run /push to push to remote")}` : "";
+      return {
+        message: `${color.green("\u2713")} Committed: ${color.bold(message)}
+  ${color.dim(hash)}${pushMsg}`
+      };
+    }
+  };
+}
+function buildGitcheckCommand() {
+  return {
+    name: "gitcheck",
+    description: "Check for uncommitted changes (for system prompt integration).",
+    aliases: ["gcstatus"],
+    async run(_args, ctx) {
+      const cwd = ctx?.cwd ?? process.cwd();
+      if (!await isGitRepo(cwd)) return { message: "" };
+      if (!await hasUncommittedChanges(cwd)) return { message: "" };
+      const statusResult = await runGit(["status", "--porcelain"], cwd);
+      const count = statusResult.stdout.split("\n").filter(Boolean).length;
+      if (count === 0) return { message: "" };
+      return {
+        message: `\u26A0 ${color.yellow(`${count} uncommitted change${count > 1 ? "s" : ""}`)} \u2014 consider /commit`
+      };
+    }
+  };
+}
+function buildPushCommand() {
+  return {
+    name: "push",
+    description: "Push to remote after commit.",
+    async run(args, ctx) {
+      const cwd = ctx?.cwd ?? process.cwd();
+      if (!await isGitRepo(cwd)) return { message: "Not a git repository." };
+      const dryRun = args.includes("--dry-run") || args.includes("-n");
+      const force = args.includes("--force") || args.includes("-f");
+      const remotes = (await runGit(["remote"], cwd)).stdout.split("\n").filter(Boolean);
+      if (remotes.length === 0) {
+        return { message: "No remote configured. Add one with: git remote add origin <url>" };
+      }
+      if (dryRun) {
+        return {
+          message: `Would push to ${remotes.join(", ")}${force ? " (force)" : ""}
+${color.dim("(dry-run)")}`
+        };
+      }
+      const branch = (await runGit(["rev-parse", "--abbrev-ref", "HEAD"], cwd)).stdout.trim() || "main";
+      const pushArgs = ["push"];
+      if (force) pushArgs.push("--force");
+      pushArgs.push(...remotes, branch);
+      const pushResult = await runGit(pushArgs, cwd);
+      if (pushResult.code !== 0) return { message: `Push failed: ${pushResult.stderr}` };
+      return { message: `${color.green("\u2713")} Pushed to ${remotes.join(", ")} (${branch})` };
+    }
+  };
+}
+
+// src/plugins/observability-plugin.ts
+function createObservabilityPlugin(opts) {
+  return {
+    name: "wstack-observability",
+    version: "1.0.0",
+    description: "Runtime metrics and health checks: /metrics, /health",
+    apiVersion: "^0.1",
+    capabilities: { slashCommands: true },
+    defaultConfig: {},
+    setup(api) {
+      const rawConfig = api.config;
+      const metricsSink = opts?.metricsSink ?? rawConfig.metricsSink;
+      const healthRegistry = opts?.healthRegistry ?? rawConfig.healthRegistry;
+      api.slashCommands.register(buildMetricsCommand(metricsSink));
+      api.slashCommands.register(buildHealthCommand(healthRegistry));
+      api.log.info("[observability] loaded \u2014 /metrics, /health available");
+    },
+    teardown(api) {
+      api.slashCommands.unregister("metrics");
+      api.slashCommands.unregister("health");
+      api.log.info("[observability] unloaded");
+    },
+    async health() {
+      return { ok: true, message: "observability ready" };
+    }
+  };
+}
+function statusIcon(status) {
+  if (status === "healthy") return color.green("\u25CF");
+  if (status === "degraded") return color.yellow("\u25CF");
+  return color.red("\u25CF");
+}
+function buildMetricsCommand(metricsSink) {
+  return {
+    name: "metrics",
+    description: "Show metrics snapshot (requires --metrics flag).",
+    async run() {
+      if (!metricsSink) {
+        return { message: "Metrics not enabled. Restart with --metrics to collect." };
+      }
+      const snap = metricsSink.snapshot();
+      if (snap.series.length === 0) return { message: "No metrics recorded yet." };
+      const lines = [];
+      const byName = /* @__PURE__ */ new Map();
+      for (const s of snap.series) {
+        const bucket = byName.get(s.name) ?? [];
+        bucket.push(s);
+        byName.set(s.name, bucket);
+      }
+      for (const [name, series] of [...byName.entries()].sort()) {
+        lines.push(color.dim(`# ${name}`));
+        for (const s of series) {
+          const labels = Object.entries(s.labels).map(([k, v]) => `${k}=${v}`).join(" ");
+          const labelStr = labels ? color.dim(` {${labels}}`) : "";
+          if (s.type === "histogram") {
+            lines.push(
+              `  count=${s.values.count} sum=${s.values.sum} min=${s.values.min} max=${s.values.max} p50=${s.values.p50} p95=${s.values.p95} p99=${s.values.p99}${labelStr}`
+            );
+          } else {
+            lines.push(`  ${s.values.value}${labelStr}`);
+          }
+        }
+      }
+      return { message: lines.join("\n") };
+    }
+  };
+}
+function buildHealthCommand(healthRegistry) {
+  return {
+    name: "health",
+    description: "Run health checks (requires --metrics flag).",
+    async run() {
+      if (!healthRegistry) {
+        return { message: "Health checks not enabled. Restart with --metrics." };
+      }
+      const result = await healthRegistry.run();
+      const lines = [
+        `${statusIcon(result.status)} overall: ${result.status}`,
+        ...result.checks.map((c) => {
+          const detail = c.detail ? color.dim(` \u2014 ${c.detail}`) : "";
+          return `  ${statusIcon(c.status)} ${c.name}: ${c.status}${detail}`;
+        })
+      ];
+      return { message: lines.join("\n") };
+    }
+  };
+}
+
+// src/plugins/security-plugin.ts
+function createSecurityPlugin() {
+  return {
+    name: "wstack-security",
+    version: "1.0.0",
+    description: "Security scanning: /security scan | audit | report",
+    apiVersion: "^0.1",
+    capabilities: { slashCommands: true },
+    defaultConfig: {},
+    setup(api) {
+      api.slashCommands.register(createSecuritySlashCommand());
+      api.log.info("[security] loaded \u2014 /security available");
+    },
+    teardown(api) {
+      api.slashCommands.unregister("security");
+      api.log.info("[security] unloaded");
+    },
+    async health() {
+      return { ok: true, message: "security scanner ready" };
+    }
+  };
+}
+function createSkillsPlugin(opts) {
+  return {
+    name: "wstack-skills",
+    version: "1.0.0",
+    description: "Skill library and GitHub installer: /skill, /skill-gen, /skill-install, ...",
+    apiVersion: "^0.1",
+    capabilities: { slashCommands: true },
+    defaultConfig: {},
+    setup(api) {
+      const rawConfig = api.config;
+      const skillLoader = opts?.skillLoader ?? rawConfig.skillLoader;
+      api.slashCommands.register(buildSkillCommand(skillLoader));
+      api.slashCommands.register(buildSkillGeneratorCommand(skillLoader));
+      api.slashCommands.register(buildSkillInstallCommand(skillLoader));
+      api.slashCommands.register(buildSkillUpdateCommand(skillLoader));
+      api.slashCommands.register(buildSkillUninstallCommand(skillLoader));
+      api.log.info("[skills] loaded \u2014 /skill, /skill-gen, /skill-install/update/uninstall available");
+    },
+    teardown(api) {
+      for (const name of ["skill", "skill-gen", "skill-install", "skill-update", "skill-uninstall"]) {
+        api.slashCommands.unregister(name);
+      }
+      api.log.info("[skills] unloaded");
+    },
+    async health() {
+      return { ok: true, message: "skills ready" };
+    }
+  };
+}
+function makeInstaller(skillLoader, projectRoot) {
+  const globalRoot = path6.join(os5.homedir(), ".wrongstack");
+  return new SkillInstaller({
+    manifestPath: path6.join(globalRoot, "installed-skills.json"),
+    projectSkillsDir: path6.join(projectRoot, ".wrongstack", "skills"),
+    globalSkillsDir: path6.join(globalRoot, "skills"),
+    projectHash: projectHash(projectRoot),
+    skillLoader
+  });
+}
+function buildSkillCommand(skillLoader) {
+  return {
+    name: "skill",
+    description: "Show skill details or list available skills. Use /skill-gen to create new skills.",
+    async run(args) {
+      if (!skillLoader) return { message: "No skill loader configured." };
+      if (!args.trim()) {
+        const entries = await skillLoader.listEntries();
+        if (entries.length === 0) return { message: "No skills found." };
+        const lines = entries.map((e) => {
+          const scopeTag = e.scope.length > 0 ? `  ${color.dim(`(${e.scope.slice(0, 3).join(", ")})`)}` : "";
+          return `  ${color.bold(e.name)}${scopeTag}
+    Use when: ${e.trigger}`;
+        });
+        return { message: `Available skills:
+${lines.join("\n\n")}
+` };
+      }
+      const skill = await skillLoader.find(args.trim());
+      if (!skill) return { message: `Skill "${args.trim()}" not found.` };
+      return { message: await skillLoader.readBody(skill.name) };
+    }
+  };
+}
+function buildSkillGeneratorCommand(skillLoader) {
+  return {
+    name: "skill-gen",
+    description: "Create a new AI skill interactively. The AI will guide you.",
+    help: [
+      "\u2554\u2550\u2550\u2550 Skill Generator \u2550\u2550\u2550\u2557",
+      "",
+      "Create new AI skills with AI guidance.",
+      "",
+      "Usage:",
+      "  /skill-gen              Start skill creation",
+      "  /skill-gen list         List existing skills",
+      "  /skill-gen edit <name>  View an existing skill",
+      "",
+      "The AI will ask you questions and create the skill file.",
+      "Skills are saved to .wrongstack/skills/<name>/SKILL.md"
+    ].join("\n"),
+    async run(args) {
+      const trimmed = args.trim();
+      if (trimmed === "list" || trimmed === "ls") {
+        if (!skillLoader) return { message: "No skill loader configured." };
+        const entries = await skillLoader.listEntries();
+        if (entries.length === 0) return { message: "No skills found." };
+        const lines = entries.map((e) => {
+          const src = e.source === "project" ? "\u{1F4C1}" : e.source === "user" ? "\u{1F464}" : "\u{1F4E6}";
+          return `  ${src} ${e.name}
+     ${e.trigger}`;
+        });
+        return { message: `Available Skills:
+${lines.join("\n\n")}
+` };
+      }
+      if (trimmed.startsWith("edit ")) {
+        const skillName = trimmed.slice(5).trim();
+        if (!skillLoader) return { message: "No skill loader configured." };
+        const skill = await skillLoader.find(skillName);
+        if (!skill) return { message: `Skill "${skillName}" not found.` };
+        const body = await skillLoader.readBody(skillName);
+        return { message: [`Skill: ${skillName}`, `Path: ${skill.path}`, "", body].join("\n") };
+      }
+      return {
+        message: "\u2554\u2550\u2550\u2550 Skill Generator \u2550\u2550\u2550\u2557\n\nThe AI will guide you through creating a new skill.\nAnswer its questions naturally.",
+        runText: "I want to create a new AI skill. Read the skill-creator skill and guide me through the process. Ask me questions one at a time \u2014 name, description, what to cover \u2014 then create the SKILL.md file."
+      };
+    }
+  };
+}
+function buildSkillInstallCommand(skillLoader) {
+  return {
+    name: "skill-install",
+    description: "Install skills from a GitHub repository.",
+    argsHint: "<user/repo[@ref]> [--global]",
+    help: [
+      "\u2554\u2550\u2550\u2550 Skill Install \u2550\u2550\u2550\u2557",
+      "",
+      "Install skills from a GitHub repository.",
+      "",
+      "Usage:",
+      "  /skill-install <user/repo>              Install from default branch (main)",
+      "  /skill-install <user/repo@ref>          Install specific tag/branch/commit",
+      "  /skill-install <user/repo> --global     Install to user-global skills",
+      "",
+      "Supports both single-skill repos (SKILL.md at root)",
+      "and multi-skill repos (skills/ subdirectory).",
+      "",
+      "Examples:",
+      "  /skill-install wrongstack/awesome-skills",
+      "  /skill-install wrongstack/skills@v1.0",
+      "  /skill-install user/my-skills --global"
+    ].join("\n"),
+    async run(args, ctx) {
+      const parts = args.trim().split(/\s+/);
+      const ref = parts.find((p) => !p.startsWith("--"));
+      const isGlobal = parts.includes("--global");
+      if (!ref) return { message: "Usage: /skill-install <user/repo[@ref]> [--global]" };
+      const installer = makeInstaller(skillLoader, ctx.projectRoot);
+      try {
+        const results = await installer.install(ref, { global: isGlobal });
+        if (results.length === 0) return { message: "No skills found in the repository." };
+        const scope = isGlobal ? "user-global" : "project";
+        const lines = [`Installed ${results.length} skill(s) [${scope}]:`];
+        for (const r of results) {
+          lines.push(`  \u2713 ${r.name} (${r.source}@${r.ref})`);
+          lines.push(`    \u2192 ${r.path}`);
+        }
+        return { message: lines.join("\n") };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { message: `\u2717 Install failed: ${msg}` };
+      }
+    }
+  };
+}
+function buildSkillUpdateCommand(skillLoader) {
+  return {
+    name: "skill-update",
+    description: "Update installed skills from their GitHub source.",
+    argsHint: "[name|ref] [--global]",
+    help: [
+      "\u2554\u2550\u2550\u2550 Skill Update \u2550\u2550\u2550\u2557",
+      "",
+      "Update installed skills from their GitHub source.",
+      "",
+      "Usage:",
+      "  /skill-update                  Update all installed skills",
+      "  /skill-update <name>           Update a specific skill",
+      "  /skill-update <user/repo@ref>  Update to a different ref",
+      "  /skill-update <name> --global  Update a global skill"
+    ].join("\n"),
+    async run(args, ctx) {
+      const parts = args.trim().split(/\s+/);
+      const nameOrRef = parts.find((p) => !p.startsWith("--"));
+      const isGlobal = parts.includes("--global");
+      const installer = makeInstaller(skillLoader, ctx.projectRoot);
+      try {
+        const result = await installer.update(nameOrRef, { global: isGlobal });
+        const lines = [];
+        if (result.updated.length > 0) {
+          lines.push(`Updated ${result.updated.length} skill(s):`);
+          for (const u of result.updated) {
+            lines.push(
+              u.oldRef !== u.newRef ? `  \u2713 ${u.name} (${u.oldRef} \u2192 ${u.newRef})` : `  \u2713 ${u.name} (refreshed)`
+            );
+          }
+        }
+        if (result.unchanged.length > 0) lines.push(`Up to date: ${result.unchanged.join(", ")}`);
+        if (result.errors.length > 0) {
+          for (const e of result.errors) lines.push(`  \u2717 ${e.name}: ${e.error}`);
+        }
+        if (lines.length === 0) return { message: "No installed skills to update." };
+        return { message: lines.join("\n") };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { message: `\u2717 Update failed: ${msg}` };
+      }
+    }
+  };
+}
+function buildSkillUninstallCommand(skillLoader) {
+  return {
+    name: "skill-uninstall",
+    description: "Remove an installed skill.",
+    argsHint: "<name> [--global]",
+    help: [
+      "\u2554\u2550\u2550\u2550 Skill Uninstall \u2550\u2550\u2550\u2557",
+      "",
+      "Remove an installed skill and its files.",
+      "",
+      "Usage:",
+      "  /skill-uninstall <name>             Remove from project skills",
+      "  /skill-uninstall <name> --global    Remove from user-global skills"
+    ].join("\n"),
+    async run(args, ctx) {
+      const parts = args.trim().split(/\s+/);
+      const name = parts.find((p) => !p.startsWith("--"));
+      const isGlobal = parts.includes("--global");
+      if (!name) {
+        const installer2 = makeInstaller(skillLoader, ctx.projectRoot);
+        const installed = await installer2.listInstalled();
+        if (installed.length === 0) return { message: "No installed skills found." };
+        const scope = isGlobal ? "user" : "project";
+        const filtered = installed.filter((s) => s.scope === scope);
+        if (filtered.length === 0) {
+          return { message: `No installed skills found (${scope} scope).` };
+        }
+        const lines = [`Installed skills (${scope}):`];
+        for (const s of filtered) {
+          lines.push(`  ${s.name}  ${s.source}@${s.ref}  (${s.installedAt.slice(0, 10)})`);
+        }
+        lines.push("", "Use /skill-uninstall <name> to remove.");
+        return { message: lines.join("\n") };
+      }
+      const installer = makeInstaller(skillLoader, ctx.projectRoot);
+      try {
+        await installer.uninstall(name, { global: isGlobal });
+        return { message: `\u2713 Skill "${name}" uninstalled.` };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { message: `\u2717 Uninstall failed: ${msg}` };
+      }
+    }
+  };
+}
+
+// src/plugins/plan-plugin.ts
+function createPlanPlugin(opts) {
+  return {
+    name: "wstack-plan",
+    version: "1.0.0",
+    description: "Strategic plan board: /plan show | add | start | done | promote | template | clear",
+    apiVersion: "^0.1",
+    capabilities: { slashCommands: true },
+    defaultConfig: {},
+    setup(api) {
+      const rawConfig = api.config;
+      const paths = opts?.paths ?? rawConfig.paths;
+      api.slashCommands.register(buildPlanCommand(paths?.projectPlan));
+      api.log.info("[plan] loaded \u2014 /plan available");
+    },
+    teardown(api) {
+      api.slashCommands.unregister("plan");
+      api.log.info("[plan] unloaded");
+    },
+    async health() {
+      return { ok: true, message: "plan board ready" };
+    }
+  };
+}
+function buildPlanCommand(planPath) {
+  return {
+    name: "plan",
+    description: "Strategic plan board: /plan [show|add <title>|start <id|#>|done <id|#>|remove <id|#>|promote <id|#> [subtask ...]|derive <id|#>|template [list|use <name>]|clear]",
+    async run(args, ctx) {
+      if (!planPath) return { message: "Plan storage is not configured for this session." };
+      const sessionId = ctx?.session?.id ?? "unknown";
+      const [verb, ...rest] = args.trim().split(/\s+/);
+      const restJoined = rest.join(" ").trim();
+      const plan = await loadPlan(planPath) ?? emptyPlan(sessionId);
+      switch (verb) {
+        case "":
+        case "show":
+        case "list":
+          return { message: formatPlan(plan) };
+        case "add": {
+          if (!restJoined) return { message: "Usage: /plan add <title>" };
+          const { plan: updated, item } = addPlanItem(plan, restJoined);
+          await savePlan(planPath, updated);
+          return { message: `Added: ${item.title}
+${formatPlan(updated)}` };
+        }
+        case "start":
+        case "progress": {
+          if (!restJoined) return { message: "Usage: /plan start <id|index>" };
+          const updated = setPlanItemStatus(plan, restJoined, "in_progress");
+          await savePlan(planPath, updated);
+          return { message: formatPlan(updated) };
+        }
+        case "done":
+        case "complete": {
+          if (!restJoined) return { message: "Usage: /plan done <id|index>" };
+          const updated = setPlanItemStatus(plan, restJoined, "done");
+          await savePlan(planPath, updated);
+          return { message: formatPlan(updated) };
+        }
+        case "remove":
+        case "delete":
+        case "rm": {
+          if (!restJoined) return { message: "Usage: /plan remove <id|index>" };
+          const updated = removePlanItem(plan, restJoined);
+          await savePlan(planPath, updated);
+          return { message: formatPlan(updated) };
+        }
+        case "promote": {
+          if (!restJoined) return { message: "Usage: /plan promote <id|index> [subtask ...]" };
+          const [target, ...subtasks] = restJoined.split(/\s+/);
+          if (!target) return { message: "Usage: /plan promote <id|index> [subtask ...]" };
+          const derived = deriveTodosFromPlanItem(plan, target, subtasks.length > 0 ? subtasks : void 0);
+          if (!derived) return { message: `No plan item matched "${target}".` };
+          await savePlan(planPath, derived.plan);
+          ctx?.state?.replaceTodos(derived.todos);
+          return {
+            message: `Promoted to ${derived.todos.length} todo(s):
+${formatTodosList(derived.todos)}
+
+${formatPlan(derived.plan)}`
+          };
+        }
+        case "derive": {
+          if (!restJoined) return { message: "Usage: /plan derive <id|index>" };
+          const derived = deriveTodosFromPlanItem(plan, restJoined);
+          if (!derived) return { message: `No plan item matched "${restJoined}".` };
+          await savePlan(planPath, derived.plan);
+          ctx?.state?.replaceTodos(derived.todos);
+          return {
+            message: `Derived ${derived.todos.length} todo(s):
+${formatTodosList(derived.todos)}
+
+${formatPlan(derived.plan)}`
+          };
+        }
+        case "template": {
+          const subVerb = rest[0] ?? "";
+          const subRest = rest.slice(1).join(" ").trim();
+          if (subVerb === "" || subVerb === "list") return { message: formatPlanTemplates() };
+          if (subVerb === "use") {
+            if (!subRest) return { message: "Usage: /plan template use <template-name>" };
+            const template = getPlanTemplate(subRest);
+            if (!template) {
+              return {
+                message: `Unknown template "${subRest}". Use /plan template list to see available templates.`
+              };
+            }
+            let updated = plan;
+            for (const item of template.items) {
+              ({ plan: updated } = addPlanItem(updated, item.title, item.details));
+            }
+            await savePlan(planPath, updated);
+            return {
+              message: `Applied template "${template.name}" (${template.items.length} items):
+${formatPlan(updated)}`
+            };
+          }
+          return { message: `Unknown template subcommand "${subVerb}". Try: list | use <name>` };
+        }
+        case "clear": {
+          const updated = clearPlan(plan);
+          await savePlan(planPath, updated);
+          return { message: "Plan cleared." };
+        }
+        default:
+          return {
+            message: `Unknown subcommand "${verb}". Try: show | add <title> | start <id|#> | done <id|#> | remove <id|#> | promote <id|#> | derive <id|#> | template [list|use <name>] | clear`
+          };
+      }
+    }
+  };
+}
+
+export { AGENTS_BY_PHASE, AGENT_CATALOG, AISpecBuilder, ALL_AGENT_DEFINITIONS, ALL_FLEET_AGENTS, ALL_SYNC_CATEGORIES, AUDIT_LOG_AGENT, Agent, AgentError, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutoPhasePlanner, AutoPhaseRunner, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, CONTEXT_WINDOW_MODES, CheckpointManager, CloudSync, ConfigError, ConfigMigrationError, Container, Context, ConversationState, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_DISPATCH_ROLE, DEFAULT_MAX_ITERATIONS, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_SUBAGENT_BASELINE, DEFAULT_TOOLS_CONFIG, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPathResolver, DefaultPermissionPolicy, DefaultPluginAPI, DefaultPromptStore, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionRewinder, DefaultSessionStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultTaskStore, DefaultTokenCounter, Director, DirectorStateCheckpoint, DoneConditionChecker, ERROR_CODES, EternalAutonomyEngine, EventBus, ExtensionRegistry, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetManager, FleetSpawnBudgetError, FleetUsageAggregator, FsError, GitignoreUpdater, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, InputBuilder, IntelligentCompactor, KERNEL_API_VERSION, LAYER_1_IDENTITY, LLMSelector, MAX_JOURNAL_ENTRIES, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, ParallelEternalEngine, PhaseGraphBuilder, PhaseOrchestrator, PhaseStore, Pipeline, PluginError, ProviderError, ProviderRegistry, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, ReportGenerator, RunController, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, ScopedEventBus, SddParallelRun, SddTaskDecomposer, SecurityScanner, SecurityScannerOrchestrator, SelectiveCompactor, SessionAnalyzer, SessionError, SkillGenerator, SkillInstaller, SkillManifestStore, SlashCommandRegistry, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TOKENS, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, TechStackDetector, ToolError, ToolExecutor, ToolRegistry, WorktreeManager, WrongStackError, addPlanItem, allServers, analyzeCriticalPath, appendJournal, applyRosterBudget, asBlocks, asText, assertSafePath, atomicWrite, attachAutoExtend, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildBtwBlock, buildChildEnv, buildGoalPreamble, buildOtlpMetricsRequest, buildOtlpTracesRequest, buildRecoveryStrategies, classifyFamily, clearPlan, color, compileGlob, compileUserRegex, composeDirectorPrompt, composeSubagentPrompt, computeTaskProgress, consumeBtwNotes, context7Server, contextManagerTool, createAutoExecutor, createAutoPhaseFromTaskGraph, createContextManagerTool, createDefaultPipelines, createDelegateTool, createGitPlugin, createMcpControlTool, createMessage, createObservabilityPlugin, createPlanPlugin, createPromptsPlugin, createSecurityPlugin, createSecuritySlashCommand, createSkillsPlugin, createSyncPlugin, createToolOutputSerializer, decryptConfigSecrets, defaultGitignoreUpdater, defaultOrchestrator, defaultReportGenerator, defaultSecurityScanner, defaultSkillGenerator, defaultTechStackDetector, deriveTodosFromPlanItem, detectNewlineStyle, dispatchAgent, downloadGitHubTarball, emptyGoal, emptyPlan, encryptConfigSecrets, ensureDir, estimateRequestTokens, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, everArtServer, extractRunEnv, filesystemServer, findCriticalPath, formatContextWindowModeList, formatGoal, formatPlan, formatPlanTemplates, formatTodosList, getAgentDefinition, getContextWindowMode, getPlanTemplate, getTemplate, githubServer, goalFilePath, googleMapsServer, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, listPlanTemplates, listTemplates, loadDirectorState, loadGoal, loadPlan, loadPlugins, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeAutonomyPromptContributor, makeContinueToNextIterationTool, makeDirectorSessionFactory, makeLLMClassifier, matchAny, matchGlob, migratePlaintextSecrets, miniMaxVisionServer, normalizeToLf, parseContinueDirective, parseSkillRef, pendingBtwCount, projectHash, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, repairToolUseAdjacency, resolveContextWindowPolicy, resolveWstackPaths, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, safeParse, safeStringify, sanitizeJsonString, saveGoal, savePlan, saveTodosCheckpoint, scoreAgents, securitySlashCommand, sentinelServer, setBtwNote, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, stripAnsi, summarizeUsage, templateToMarkdown, toStyle, toWrongStackError, topologicalSort, unifiedDiff, unloadPlugins, validateAgainstSchema, wireMetricsToEvents, wrapAsState, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map